物联网综合应用讲义（研究生）-02 嵌入式软件设计专题

物联网 讲义 嵌入式软件

1 嵌入式软件架构概述

1.1 经典的合作式调度器

考虑这样一个常见的系统：、

• 周期性任务：
  
  • 每0.5s发光二极管闪烁一次；
  • 每50ms检测是否有键按下；
  • 每200ms刷新一次LED数码管显示器；
  • 每100ms采集一次开关量输入信号；
  • 每100ms采集一次A/D输入信号。
• 非周期性任务
  
  • 通信处理任务;
  • 控制任务

经典方法：前后台系统（超级循环）

• 后台：非中断驱动的任务：如控制任务
• 前台：中断驱动的任务
• 周期性任务都由硬件定时器驱动
• 周期性任务在中断服务子程序中完成。

问题

• 每个任务需要一个定时器；
• 中断源太多使系统不可靠性降低，某些中断可能会被漏掉。

如何解决以上问题？

• 信号量的使用： 用一个定时器产生时标，所有周期性任务共用该 定时器，当某任务的定时时间到，发出信号。
• 协作式调度（将周期性任务也当做后台任务）
• 前台任务：中断驱动的任务，如串行数据的接收
• 原则：中断尽可能短，只发信号，将业务逻辑处理函数放在后台运行。
  

参考代码

#include <reg51.h>
#include "common.h"
#define FOSC 11059200ul
#define T0_H (65536-(10*FOSC)/(12*1000))/256 
#define T0_L (65536-(10*FOSC)/(12*1000))%256 
uint16_t tick = 0;
bit bFlag1 = 0;
bit bFlag2 = 0;
bit bFlag3 = 0;
bit bFlag4 = 0;
void initSys();
sbit LED0 = P1^0;
sbit LED1 = P1^1;
sbit LED2 = P1^2;
sbit LED3 = P1^3;
void main(){
    initSys();
    while(TRUE){
        if(bFlag1){
            bFlag1 = 0;
            LED0 = !LED0;
        }
        if(bFlag2){
            bFlag2 = 0;
            LED1 = !LED1;
        }
        if(bFlag3){
            bFlag3 = 0;
            LED2 = !LED2;
        }
        if(bFlag4){
            bFlag4 = 0;
            LED3 = !LED3;
        }
    }
}
void initSys(){
    TMOD = 0x01;
    TH0 = T0_H;
    TL0 = T0_L;
    EA = 1;
    ET0 = 1;
    TR0 = 1;
}
void timer0() interrupt 1 {
    TH0 = T0_H;
    TL0 = T0_L;
    tick++;
    if((tick % 100) == 0){
        bFlag1 = 1;
    }
    if((tick % 150) == 3){
        bFlag2 = 1;
    }
    if((tick % 20) == 5){
        bFlag3 = 1;
    }
    if((tick % 300) == 7){
        bFlag4 = 1;
    }    
}

1.2 长任务的处理：用状态机切割任务

新的问题？

• 如何处理“长”任务？例如串行数据接收及解析任务。
• 方法：将任务切割为若干个“短”的子任务。
• 在超级循环中每次只执行长任务的一个子任务，保证其他任务有机会执行。
• 每个子任务都具有一个状态，通过对状态的分发完成整个任务。

有限状态机的概念：FSM

以下都是状态机$\rightarrow$程序其实就是状态机

• 按键处理：按下、去抖、闭合、释放、去抖
• 串行通信的时序（串口、IIC、SPI、红外、无线）
• 显示扫描程序（动态刷新LED）
• 通信命令解析程序连继电器的吸合/释放控制
• 发光管（LED）的亮/灭控制

状态机的要素

1. 状态：是指当前所处的状态。
2. 条件：又称为“事件”。当一个条件被满足，将会触 发一个动作，或者执行一次状态的迁移。
3. 动作：条件满足后执行的动作。动作执行完毕后， 可以迁移到新的状态，也可以仍旧保持原状态。动 作不是必需的，当条件满足后，也可以不执行任何 动作，直接迁移到新状态。
4. 次态：条件满足后要迁往的新状态
   

! image.png-443.2kB

状态机的实现方法

• 用if语句实现状态机

void Task1Function(void) {
    If(taskState==STATE1) { 
        执行动作1（）； 
        taskState=STATE2;
        return; 
    }
    If(taskState==STATE2) {
        执行动作2（）； 
        taskState=STATE3;
        return; 
    }
    If(taskState==STATE3) { 
        执行动作3（）； 
        taskState=STATE4;
        return; 
    } 
    If(taskState==STATE4) {
        执行动作4（）； 
        taskState=STATE1;
        return; 
    }
}

• 用switch case语句实现状态机

void Task1Function(void) {
    switch(taskState) { 
        case STATE1: { 
            执行动作1（）； 
            taskState=STATE2; 
            break;
        }
        case STATE2: {
            执行动作2（）；
            taskState=STATE3;
            break;
        }
        case STATE3: {
            执行动作3（）；
            taskState=STATE4;
            break;
        }
        case STATE4: {
            执行动作4（）； 
            taskState=STATE1;
            break; 
        }
        default:{ 
            执行动作5（）；
            taskState=STATE1;
        }
}

• 查表（不作介绍）
• 用函数指针实现
  函数指针的用法 观察以下函数

    void  fun1(void) { 
    } 

编译器会如何处理？（汇编代码 ）
调用该函数的方法：

    fun1();
    void (*pFun1)() = fun1;
    //调用该函数的方法： 
    (*pFun1)()； 
    //或
    pFun1();

用函数指针代替switch case语 句实现一个计算器
代码片段

double  caculate(int oper, doubleop1, double op2) 
    switch( oper) { 
        case ADD:
            result = add( op1, op2); 
            break;
        case SUB: 
            result = sub( op1, op2);
            break;
        case MUL: 
            result = mul( op1, op2); 
            break; 
        case DIV: 
            result = div( op1, op2); 
            break;
    }
}

对于一个新奇的具有上百个操作符的计算器，这条switch语句将非常长。
编译器的问题：可能会将多个case语句的代码编译为if/else 结构,当然也可能优化为函数指针结构。

//使用函数指针实现：代码片段
//函数声明 
double add （double，double）；
double sub （double，double）；
double mul（double，double）；
double div （double，double）；
......
double （*oper_func[ ] ）( double, double)={ add,sub,mul,div,... };
//用下面这条语句替换前面整条switch 语句！ 
result = oper_func[oper](op1, op2);
//或
result = （*oper_func[ oper]）(op1, op2);

状态机的函数指针实现：

typedef void(*State)(Fsm *me, unsigned const sig);
 /*状态定义：函数指针，状态迁移后直接调用对应的处理函数*/  
struct Fsm{
    State state_;/* 状态机本身由函数指针实现*/ 
};
#define FsmDispatch(me_, sig_) ((*(me_)->state_)((me_), sig)) 
/*状态分发，代替任务函数*/ 
#define TRAN(target_) (((Fsm*) me)->state_ = (State)(target_)) /*状态迁移*/ /*状态函数（子任务）*/ 
void FsmFunction1(Fsm *me, unsigned const sig) { 
    switch (sig) { 
        case SLASH_SIG: 
            //do sth here; 
            TRAN(FsmFunction2); /* 迁移到下一个状态*/ 
            break;
    } 
        //...
}

1.3 合作式调度器+有限状态机

嵌入式软件架构设计之 合作式调度器+有限状态机架构的实现方法

main() { 
    A_taskInit();//任务的初始化 
    B_taskInit(); 
    ... 
    while(1) {
        A_taskProc();//对于长任务，用状态机切割 
        B_taskProc();
    ｝ 
}

关于延时的实现方法，以下为OS支持下任务的写法

void xxxTask(void) {
    while(1){ 
        //waitEvent
        //do step_1
        /*操作系统延时，让出CPU*/
        rt_thread_sleep(rt_tick_t tick);
        rt_thread_delay(rt_tick_t tick);
        rt_thread_mdelay(rt_int32_t ms);
        //do step2
    }
}
void xxxTask(void) { 
    static unsigned inttaskStat= STAT_GENERAL;//任务状态变量        static rt_tick_t startTick; 
    static rt_tick_t tick currentTick;
    if (taskStat == STAT_GENERAL) {
        //check event
        //if no event
        return;
        //do step_1
        startTick = rt_tick_get();  //rt_tick_get()就是察看系统时间 
        taskStat = STAT_WAIT;
        return;
    }
    else if (taskStat == STAT_WAIT) {
        currTick= rt_tick_get();
        if ((currTick-startTick) >= TIME_OUT_TICK_NUM) { 
            //do step_2
            taskStat= STAT_GENERAL;
            return;
    } 
    else return;
} 

1.4 举例：8通道A/D采集任务的状态化

方法：将8通道采集切割为8个子任务

//不切割任务的方法 
uint8_t ad_chnnel; 
for(ad_chnnel = 0; ad_chnnel < 8; ad_chnnel++) {   
    //AD转换,通道号ad_chnnel由for语句自动加1，连续转换8次
    temperature = read_ad(ad_chnnel);
    ad_result[ad_chnnel] = temperature;//存入数组 
}

//切割任务的方法，每次只进行一次转换 
static uint8_t ad_chnnel = 0; //声明为全局变量 
if(ad_chnnel < 8) {
    temperature = read_ad(ad_chnnel);//AD转换,         
    ad_result[ad_chnnel] = temperature;//存入数组  
    ad_chnnel++;//通道号加1 
}
else
    ad_chnnel = 0;

1.5 举例：生产者-消费者设计模式-以modbus协议的实现

• 应用很广的设计模式：生产者-消费者设计模式
• 信息生产者$\rightarrow$环形缓冲区者$\rightarrow$信息消费者
• 模块化，不同模块解耦（软件工程：高内聚，低耦合）
• 同步方式的问题（任务阻塞），对于串口这样的低速外设 无法忍受（19200bps下传输1帧数据需要约30ms）
• 生产者产生信息的时间可能不均匀
  
  • 实现方法：中断将串口数据存入环形缓冲区，主程序调用通 信解析任务解析该协议，执行相应动作。适合存储能力和 运算能力强的嵌入式系统。收下来一起解析。
    

1.6 如何处理μs级、时序要求严格的任务？

这种方法的主体思想是：利用一个独立的定时器，在其中断处理程序中根据状态的不同 ，动态的修改TCNTn的值，并执行相应状态的代码

typedef void(*lfsm_func_t)(void); 
typedef struct { 
    uint8_t delta_t; 
    lfsm_func_t fsm_func;     
    lfsm_t *next_fsm;//一定要形成一个环形链表 
}lfsm_t;
//初始化
lfsm fsm_18B20[]= { …如何初始化？ } 
void timer0_ISR(void) { 
    static lfsm_t * current_fsm = fsm_18B20;
    lfsm_t *temp_fsm = current_fsm;
    TCNT0 = current_fsm->delta_t;//修改到达下一次中断的时间
    current_fsm = current_fsm->next_fsm; 
    temp_fsm->fsm_func();//调用状态机
}  

1.7 使用实时操作系统(RTOS)

在RTOS环境下，一般提供抢占式调度。RTOS环境下的任 务，一般处于一个while(1)循环中。

while(1){
    从消息队列接收消息。如果没有，将阻塞。 处理消息。
｝

2 嵌入式软件设计之编码规范

• 参考文献：
  
  1. 林锐高质量C++/C编程指南
  2. 华为编程规范
  3. 代码简洁之道
  4. http://openresty.org/cn/c-coding-style-guide.html

2.1 排版

1. 程序块要采用缩进风格编写，缩进的空格数为4个。
2. 较长的语句（>80字符）要分成多行书写，长表达式要在低 优先级操作符处划分新行，操作符放在新行之首，划分出的新行要进行适当的缩进，使排版整齐，语句可读。
3. 一行只写一条语句。
4. 函数或过程的开始、结构的定义及循环、判断等语句中的代 码都要采用缩进风格，case语句下的情况处理语句也要遵从 语句缩进要求。

//范例1： 
void Fun1(int iCh) {
    intI,j,iTmp; 
    i=0;
    if(iCh<8) {
        GetAdValue();
    }
}
//范例2：
void Fun2(int iCh) 
{
    switch(iCh)
    {
        case 0: 
            GetAdValue(iCH); 
            break; 
        case 1: … 
    }
}

2.2 注释

1. 源程序有效注释量一般在10%-20％。
2. 注释应当准确、易懂，防止注释有二义性。
3. 注释的位置应与被描述的代码相邻，可以放在代码的上方或右方，不可放在下方。
4. 当代码比较长，特别是有多重嵌套时，应当在一些段落的结束处加注释，便于阅读。
5. 留白，占代码量的20%

2.3 命名规则

关于命名的风格，应用比较广的有三种。

• 第一种风格叫“匈牙利命名法”，在早期的 Windows 上很流行，使用前缀 i/n/sz 等来表示变量的类型，比如iNum/szName。它把类型信息做了“硬编码”，不适合代码重构和泛型编程，所以目前基本上被淘汰了。不过它里面有一种做法值得借鉴，就是给成员变量加“m_”前缀（member），给全局变量加“g_”前缀（global），比如m_count、g_total，这样一看就知道了变量的作用域，在大型程序里还是挺有用的。
• 第二种风格叫“CamelCase”，也就是“驼峰式命名法”，在 Java 语言里非常流行，主张单词首字母大写，比如 MyJobClass、tryToLock，但这种风格在 C++ 世界里的接受程度不是太高。
• 第三种风格叫“snake_case”，用的是全小写，单词之间用下划线连接。这是 C 和 C++ 主要采用的命名方式，看一下标准库，里面的 vector、unordered_set、shrink_to_fit 都是这样。

那么，该选用哪种命名风格呢？建议是“取百家之长”，混用这几种中能够让名字辨识度最高的那些优点：

• 变量、函数名和名字空间用snake_case,全局变量加“g_”前缀；
• 自定义类名用 CamelCase,成员函数用snake_case，成员变量加“m_”前缀；
• 宏和常量应当全大写，单词之间用下划线连接；
• 尽量不要用下划线作为变量的前缀或者后缀（比如 local、name），很难识别.
• 用 _t 作为 typedef 中指代结构体的类型名称后缀 ， _s 用于 struct 名称后缀
• 函数名一般采用动名词结构 refresh_led()、update_data()、 get_temperature()、set_para()
• 文件名（在C语言中为1个模块）：名字要有意义,英文名称准确 采用下划线断句，一般采用名词、形容词+名词或动名词结构 如：
  
  • collect_data.c
  • pid.c
  • gui_drawline.c
  • hex2dec.c
  • gui_core.c

#define  MAX_PATH_LEN  256             //常量，全大写
#define  BUAD_RATE  19200 
int g_sys_flag;                        // 全局变量，加g_前缀
float g_currentValue;
//类型定义加_t后缀
typedef struct {
    WSAOVERLAPPED    ovlp;
    ngx_event_t     *event;
    int              error;
} ngx_event_ovlp_t;
//结构体定义加_s后缀
struct ngx_chain_s {
    ngx_buf_t    *buf;
    ngx_chain_t  *next;
};
namespace linux_sys {                // 名字空间，全小写
  void get_rlimit_core();               // 函数，全小写
}
class FilePath final                 // 类名，首字母大写
{
public:
  void set_path(const string& str);    // 函数，全小写
private:  
  string m_path;                      // 成员变量，m_前缀 
  int    m_level;                     // 成员变量，m_前缀
};

命名另一个相关的问题是“名字的长度”,一个被普遍认可的原则是：变量 / 函数的名字长度与它的作用域成正比，也就是说，局部变量 / 函数名可以短一点，而全局变量 / 函数名应该长一点。

3 嵌入式软件设计之C语言编程要点

3.1 C语言的几个关键字

1. define 用预处理指令#define声明一个常数

   • #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)ul
   • #define 语法的基本知识（不能以分号结束，括号的使用）
   • 书写注意可读性。
   • 意识到这个表达式将使一个16 位机的整型数溢出,因此要用 到长整型符号l,告诉编译器这个常数是的长整型数。
   • 如果你在你的表达式中用到ul（表示无符号长整型），那 么你有了一个好的起点。
   • 写一个"标准"宏MIN
#define MIN(A,B) ((A)<= (B) ? (A) : (B))
   • 使用宏嵌入代码。对于嵌入式系统来说，为了能达到要求 的性能，嵌入代码经常是必须的方法。（思考：与函数相 比的优点，另外一个嵌入代码的方法是使用inline关键字声明 内联函数）
   • 三重条件操作符，产生比if-then-else 更优化的代码。
   • 宏中参数用括号括起来
   • 宏的副作用，例如：
   • least = MIN(*p++, b); //思考：有什么副作用？

2. static

   • 第1种用法：函数体内的static,供函数使用的全局变量

void fun1(void) { 
    static int counts= 0 ;
    counts++;
}
fun1();
fun1();
fun1();

• 第2种用法：模块内的static, 供本模块使用的全局变量，供本模块所有函数访问。

static int counts2; 
void fun1(void) { 
    counts2= 0 ;
    counts2++; 
}
void fun2(void) {
    counts2++; 
}
fun1(); 
fun2();

• 第3种用法：模块内的static,仅供本模块使用的函数

static void fun1(void) { 
    counts3= 0 ; 
    counts++;
} 

- 作用：仅供本模块函数调用
- 以上第2，3种用法： 本地化数据和代码范围的好处和重要性

3. const

const int tmp; 
int const tmp; 
const int* ptr1; //问题：pData值是否可变？
int* const ptr2; 
//问题：ptr2值是否可变？ 
int const * ptr3 const;//问题：ptr3值是否可变？

思考：编译器如何处理？地址分配在什么地方？
使用const关键字的好处：
- 给读你代码的人传达非常有用的信息.
- 给优化器一些附加的信息,能产生更紧凑的代码。
- 使编译器很自然地保护那些不希望被改变的参数 ，防止其被无意的代码修改。
4. volatile

• 原意：易变的 C语言：告诉编译器该变量易变，不要优化它。 一个定义为volatile 的变量是说这变量可能会被意想不到地 改变，这样，编译器就不会去假设这个变量的值了。精 确地说就是，优化器在用到这个变量时必须每次都小心 地重新读取这个变量的值，而不是使用保存在寄存器里 的备份。
• 硬件寄存器（如：状态寄存器）
• #define rNCACHBE0 (*(volatile unsigned *)0x1c00004)
• #define rNCACHBE1 (*(volatile unsigned *)0x1c00008)
• 一个中断服务子程序中会访问到的非自动变量(Nonautomatic variables)
• 多线程应用中被几个任务共享的变量

5.typedef:类型定义

#define mys_s struct s* 
typedef struct s* mys_t;
mys_s p1,p2;
mys_t p3,p4;

以上有什么区别？ typedef的作用
6. extern 声明外部变量 跨模块的全局变量

moudule1.c 
int iState;
moudule2.c
extern int iState;

变量(函数)声明与定义的区别:
声明:不分配存储空间，定义:分配存储空间 以下那个是申明,那个是定义?

extern int x = 1024;
int y;
extern void reset (void *p) {} 
extern const int *pi;
void print(const matrix &);

1. 内嵌汇编 __asm

int result;
void Add(long a, long *b) {
    __asm{
        MOV AX, a 
        MOV BX, b 
        ADD AX, [BX] 
        MOV result, AX
    }
}
__asm void wait() {
    nop
    nop
    nop
    nop
    nop
    nop
    BX lr
}

3.2 C语言编程要点

3.2.1 访问固定内存

• 将地址为0x67a9内存赋值为0xaa55
• 知识点:强制类型转换

int *ptr;
ptr = (int *)0x67a9; 
*ptr = 0xaa55;

一个较晦涩的方法是:

*(int * const)(0x67a9) = 0xaa55;

3.2.2 关于中断(__interrupt)

#define PI (3.1415926)
float EXTI0_IRQHandler(float fRadius ){
    double area = PI * fRadius * fRadius ; // 
    printf("\nArea = %f", area);
    return area;
}

• 错误1:中断不能带返回值
• 错误2:中断不能传递参数
• 错误3:大多数处理器/编译器中，浮点一般都是不可重入的。

• 错误4:printf()是不可重入的

• 知识点:函数的可重入性(reentrant)

  • 可 重入函数可以由多于一个任务并发使用，而不必担心数 据错误。
  • 不可重入(non-reentrant)函数不能由超过一个任务所共 享，除非能确保函数的互斥(或者使用信号量，或者在代码 的关键部分禁用中断)。
  • 可重入函数可以在任意时刻被中断，稍后再继续运行，不 会丢失数据。
  • 可重入函数要么使用本地变量，要么在使用全局变量时保护 自己的数据。

总的来说，如果一个函数在重 入条件下使用了未受保护的共
享的资源，那么它是不可重入 的。 示例:

int tmp;
void func1(int* x, int* y) {
    tmp = *x; 
    *x = *y; 
    *y = tmp;
}
void swap_char2(char *lpcX, char *lpcY) {
    static char cTemp;
    cTemp = *lpcX; 
    *lpcX = *lpcY; 
    lpcY = cTemp;
}
void func2(int* x, int* y) { 
    int tmp;
    tmp = *x; 
    *x = *y; 
    *y = tmp;
}

共享数据的问题(中断的数据保护)

static int temperatures[2];
void main(void) {
    int temp0,temp1;
    while(TURE){
        temp0 = temperatures[0]; 
        temp1 = temperatures[1];
        if(iTemp0 != iTemp1){
            ...
        }
    }
}
void interrupt reead_temperatures(void) {
    temperatures[0] = ??;//从硬件读取温 度值
??//
    temperatures[1] = ??;//从硬件读取温 度值
} 

思考:如果第1条赋值语句被中断会发生什么?
解决方案：

• 在两条赋值语句前后关开中断
• 原子操作(关键段)

disable_interrupt;
    temp0 = temperatures[0]; 
    temp1 = temperatures[1];
enable_interrupt;

共享数据的问题(中断的数据保护)
以下代码有什么问题?如何修改？

static int iSeconds , iMinutes , iHours; 

3.2.3 模块划分

• 模块即是一个.c文件和一个.h文件的结合，头文件(.h)中
  是对于该模块接口的声明;(软件工程:接口与实现分开)
• 某模块提供给其它模块调用的外部函数及数据需在.h中
  文件中冠以extern关键字声明;
• 模块内的函数和全局变量需在.c文件开头冠以static关
  键字声明;
• 永远不要在.h文件中定义变量!定义变量和声明变量的
  区别在于定义会产生内存分配的操作，是汇编阶段的概念;
  而声明则只是告诉包含该声明的模块在连接阶段从其它模块
  寻找外部函数和变量。

/*module1.h*/
int a = 5; /* 在模块1的.h文件中定义int a */
/*module1 .c*/
#include "module1.h" /* 在模块1中包含模块1的.h文件 */
/*module2 .c*/
#include "module1.h" /* 在模块2中包含模块1的.h文件 */ 
/*module3 .c*/
#include "module1.h" /* 在模块3中包含模块1的.h文件 */

以上代码有什么问题?
正确的方法

/*module1.h*/
extern int a; /* 在模块1的.h文件中声明int a */
/*module1.c*/
#include "module1.h" /* 在模块1中包含模块1的.h文件 */ 
int a = 5; /* 在模块1的.c文件中定义int a */
/*module2 .c*/
#include "module1.h" /* 在模块2中包含模块1的.h文件 */
/*module3 .c*/
#include "module1.h" /* 在模块3中包含模块1的.h文件 */

划分模块的原则:以下是最简单的划分方法 一个嵌入式系统通常包括两类模块:
1. 硬件驱动模块
一种特定硬件对应一个模块;
一个硬件驱动模块通常应包括如下函数:

• 中断服务程序ISR
• 硬件初始化(寄存器配置，中断向量挂接)
• 设置CPU针对该硬件的控制线(例如GPIO设置)
• 提供一系列针对该设备的操作接口函数。
  例如:读、写、设置工作方式等

2.软件功能模块
其模块的划分应满足低耦合、高内聚的要求。
例如:主程序1个模块

• 数据采集程序1个模块
• 显示程序一个模块

如何避免重复引用头文件:

module1.h
#ifndef _module1_h
    #define _module1_h
    ....//头文件具体内容
#endif