基本数字逻辑门电路

不管是数字电路，还是C语言，我们都会经常遇到逻辑运算和逻辑电路。

首先，在“逻辑”这个概念范畴内，存在真和假这两个逻辑值，而将其对应到数字电路或C语言中，就变成了“非0值”和“0值”这两个值，即逻辑上的“假”就是数字电路或C语言中的“0”这个值，而逻辑“真”就是其它一切“非0值”。

然后，来具体分析一下几个主要的逻辑运算符。假定有2个字节变量：A和B，二者进行某种逻辑运算后的结果为F。以下逻辑运算符都是按照变量整体值进行运算的，通常就叫做逻辑运算符：

• &&： 逻辑与，F = A && B，当A、B的值都为真（即非0值，下同）时，其运算结果F为真（具体数值为1，下同）；当A、B值任意一个为假（即0，下同）时，结果F为假（具体数值为0，下同）。

• ||：逻辑或，F = A || B，当A、B值任意一个为真时，其运算结果F为真；当A、B值都为假时，结果F为假。

• ! ：逻辑非，F = !A，当A值为假时，其运算结果F为真；当A值为真时，结果F为假。

以下逻辑运算符都是按照变量内的每一个位来进行运算的，通常就叫做位运算符：

• & ：按位与，F = A & B，将A、B两个字节中的每一位都进行与运算，再将得到的每一位结果组合为总结果F，例如A = 0b11001100，B = 0b11110000，则结果F就等于0b11000000。

• | ：按位或，F = A | B，将A、B两个字节中的每一位都进行或运算，再将得到的每一位结果组合为总结果F，例如A = 0b11001100，B = 0b11110000，则结果F就等于0b11111100。

• ~ ：按位取反，F = ~A，将A字节内的每一位进行非运算（就是取反），再将得到的每一位结果组合为总结果F，例如，A = 0b11001100，则结果F就等于0b00110011；这个运算符我们在前面的流水灯实验里已经用过了，现在再回头看一眼，是不是清楚多了。

• ^ ：按位异或，F = A ^ B，异或的意思是，如果运算双方的值不同（即相异）则结果为真，双方值相同则结果为假。在C语言里没有按变量整体值进行的异或运算，所以我们仅以按位异或为例，F = A ^ B，A = 0b11001100，B = 0b11110000，则结果F就等于0b00111100。

要看资料或芯片手册的时候，会经常遇到一些电路符号，表1就是数字电路中的常用符号，知道这些符号有利于我们理解器件的逻辑结构，尤其重点认识以下表中的“国外流行图形符号”。在这里我们先简单看一下，后边遇到了知道到这里查阅就可以了。

定时器

定时器是单片机的重点中的重点，但不是难点，大家一定要完全理解并且熟练掌握定时器的应用。

• 时钟周期：时钟周期T是时序中最小的时间单位具体计算的方法就是1/时钟源，如果大家用的晶振是11.0592M，那么对于这个单片机系统来说，时钟周期=1/11059200秒。

• 机器周期：我们的单片机完成一个操作的最短时间。机器周期主要针对汇编语言而言，在汇编语言下程序的每一条语句执行所使用的时间都是机器周期的整数倍，而且语句占用的时间是可以计算出来的，而C语言一条语句的时间是不可计算的。51单片机系列，在其标准架构下一个机器周期是12个时钟周期，也就是12/11059200秒。现在有不少增强型的51单片机，其速度都比较快，有的1个机器周期等于4个时钟周期，有的1个机器周期就等于1个时钟周期，也就是说大体上其速度可以达到标准51架构的3倍或12倍。

这两个概念了解即可，下边就来重头戏，定时器和计数器。定时器和计数器是单片机内部的同一个模块，通过配置SFR（特殊功能寄存器）可以实现两种不同的功能，大多数情况下是使用定时器功能，计数器功能大家自己了解下即可。

顾名思义，定时器就是用来进行定时的。定时器内部有一个寄存器，让它开始计数后，这个寄存器的值每经过一个机器周期就会加1一次，因此，可以把机器周期理解为定时器的计数周期。秒表每经过一秒，数字加1，而这个定时器就是每过一个机器周期的时间，也就是12/11059200秒，数字加1。

还有一个特别注意的地方，就是秒表是加到60后，秒就自动变成0了，这种情况在单片机和计算机里称之为溢出。那定时器加到多少才会溢出呢？定时器有几种模式，假如是16位的定时器，也就是2个字节，最大值就是65535，那么加到65535后，再加1就算溢出，如果有其他位数的话，道理是一样的，对于51单片机来说，溢出后，这个值会直接变成0。从某一个初值，经过计算确定的时间后溢出，这个过程就是其定时的含义。

定时器的寄存器描述

标准的51里边只有定时器0和定时器1这两个定时器，现在很多单片机也有多个定时器的，在这里先讲定时器0和1。前边提到过，对于单片机的每一个功能模块，都是由他的SFR，也就是特殊功能寄存器来控制。

而和定时器有关的特殊功能寄存器，有以下几个，大家不需要去记忆这些寄存器的名字和作用，你只要大概知道就行，用的时候，随时可以查手册，找到每个寄存器的名字和每个寄存器所起到的作用。

表2中的寄存器，是存储计数器的计数值的，两个字节的用于定时器1，两个字节用于定时器0。

表3中有TF1、TR1、TF0、TR0这4位需要理解清楚。两位定时器1的，两位定时器0的，只解释定时器1的，定时器0的同理。先看TR1，当我们程序中写TR1 = 1以后，定时器值就会每经过一个机器周期加1，当程序中写TR1 = 0以后，定时器值就会保持不变化。TF1，这个是一个标志位，它的作用是告诉定时器溢出了。

比如定时器设置成16位的定时器，那么每经过一个机器周期，TL1加1一次，当TL1加到255后，再加1，TL1变成0，TH1会加1一次，如此一直加到TH1和TL1都是255（即TH1和TL1组成的16位整型数为65535）以后，再加1一次，那么就会溢出，TH1和TL1同时都变为0，只要一溢出，TF1马上自动变成1，告诉定时器溢出了，仅仅是提供给一个信号，让知道定时器溢出了，它不会对定时器是否继续运行产生任何影响。

注意在表4中的描述中，只要写到硬件置1或者清0的，就是指一旦符合条件，单片机自动完成的动作，只要写软件置1或者清0的，是指用程序去完成这个动作。

TCON是“可位寻址”，TMOD是“不可位寻址”。这个地方的意思就是比如TCON有一位TR1，我们可以在程序中直接进行TR1 = 1，这样操作。但是(T1)M1 = 1，这样的操作就是错误的，操作就必须一次操作一个字节，就是必须一次性对TMOD所有位操作，不能对其中某一位单独进行操作。

以上这4种模式的配置，其中模式0是为了兼容老的8048单片机而设的，现在的51几乎不会用到这种模式，而模式3根据应用经验，他的功能模式2完全可以取代，所以基本上也是不用，重点就学习模式1和模式2。

• 模式1：就是THn和TLn组成了一个16位的定时器，取值范围是0到65535，溢出后，只要不对THn和TLn重新赋值，则从0开始计数。

• 模式2：的功能是自动装载，就是TLn溢出后，TFn就直接置1了，并且THn的值直接赋给TLn，然后TLn从新赋值的这个数字开始计数，这个功能可以用来产生串口的通信波特率。

理解定时器原理

为了加深大家理解这个定时器原理，来看一下模式1的电路示意图1。

分析一下这个示意图，OSC框表示时钟频率，因为1个机器周期等于12个时钟周期，所以那个d就等于12。下边GATA右边的那个门是一个非门电路，再右侧是一个或门，再往右是一个与门电路。

图上可以看出来，下边部分电路是控制了上边部分，那我们先来看下边是如何控制的，我们以定时器0为例。

• TR0和下边或门电路的结果要进行与门运算，TR0如果是0的话，与运算完了肯定是0，所以确定如果要让定时器工作，TR0 = 1。

• 与门结果要想是1，那或门出来的信号必须也得是1才行。在GATE位为1的情况下，经过一个非门变成0，或门电路结果要想是1的话，那INT0即P3.2引脚必须是1的情况下，这个时候定时器才会工作，而INT0引脚是0的情况下，定时器不工作，这就是GATE位的作用。

• 当GATE位为0的时候，经过一个非门变成1，不管INT0引脚是什么电平，经过或门电路后则肯定是1，定时器就会工作。

• 要想让定时器工作，就是加1，从图上看有两种方式，第一种方式是那个开关打到上边的箭头，就是C/T = 0的时候，一个机器周期TL就会加1一次，当开关打到下边的箭头，即C/T =1的时候，T0引脚即P3.4引脚来一个脉冲，TL就加1一次，这也就是计数器功能。（INT0引脚是P3.2，INT1引脚是P3.3，T0引脚是P3.4，T1引脚是P3.5。）

定时器程序应用

了解了定时器相关的寄存器，那么我们下面就来做一个定时器的程序，巩固一下我们学到的内容。我们这节课的程序先使用定时器0，在使用定时器的时候，需要以下几个步骤：

1、设置特殊功能寄存器TMOD，配置好工作模式；

2、设置计数寄存器TH0和TL0的初值；

3、设置TCON，通过打开TR0位来让定时器开始计数。

4、判断TCON寄存器的TF0位，监测定时器溢出情况。

写程序之前，要先来学会计算如何用定时器定时时间。以晶振是11.0592M为例讲解，时钟周期就是1/11059200，机器周期就是12/11059200，假如要定时20ms就是0.02秒，要经过x个机器周期得到0.02秒，算一下x*12/11059200 = 0.02，得到x = 18432。

那么现在16位的定时器溢出值是65536，可以这样，先给TH0和TL0一个初值，让他们经过18432个机器周期后刚好溢出，溢出后可以通过检测TF0位得知，就刚好是0.02秒。这个初值y = 65536 - 18432 = 47104，转成16进制就是0xB800，那么就是TH0 = 0xB8，TL0 = 0x00。

那0.02秒已经定时出来了，细心的同学会发现，如果初值直接给一个0x0000，一直到65536溢出，定时器定时值最大也就是71ms左右，那么想定时更长时间怎么办呢？用你小学学过的逻辑，倍数关系就可以解决此问题。

本程序实现的结果是小灯点亮持续一秒，熄灭持续一秒，也就是以0.5HZ的频率进行闪烁。那好了，我们下面就用程序来实现以下这个功能。

#include //包含寄存器的库文件

sbit LED = P0^0;

sbit ADDR0 = P1^0;

sbit ADDR1 = P1^1;

sbit ADDR2 = P1^2;

sbit ADDR3 = P1^3;

sbit ENLED = P1^4;

void main()

{

unsigned char counter = 0;

ENLED = 0; ADDR0 = 0; ADDR1 = 1;

ADDR2 = 1; ADDR3 = 1; LED = 1; //74HC138和LED灯初始化部分

TMOD = 0x01; //设置定时器0为模式1

TH0 = 0xB8;

TL0 = 0x00; //定时值初值

TR0 = 1; //打开定时器0

while(1)

{

if(1 == TF0) //判断定时器0是否溢出

{

TF0 = 0;

TH0 = 0xB8; //一旦溢出后，重新赋值

TL0 = 0x00;

counter++;

if(50 == counter) //判断定时器0溢出是否达到50次

{

counter = 0; //counter清0，重新计数

LED = !LED; //LED取反操作，0-->1，1-->0

}

}

}

}

程序都有注释，不难理解，这里要解释一个地方，就是两次if判断。细心的同学会发现，if(1 == TF0)这句，1写前边，因为如果写if(TF0 == 1)，作为新手来说，不小心丢掉一个’=’号后，写成if(TF0 = 1)，这样实际上在语法上是可以通过的，用的Keil4还会出一个警告说明一下，Keil以前的版本及一些其他软件，可能根本不会出任何错误或者警告提示，但这样产生的Hex文件下载到单片机里边，程序就错了，大家可以改改试试看。

本文主要介绍在嵌入式开发中用来输出log的方法。

最常用的是通过串口输出uart log，这种方法实现简单，大部分嵌入式芯片都有串口功能。但是这样简单的功能有时候却不是那么好用，比如：

• 一款新拿到的芯片，没有串口驱动时如何打印log

• 某些应用下对时序要求比较高，串口输出log占用时间太长怎么办？比如USB枚举。

•  某些bug正常运行时会出现，当打开串口log时又不再复现怎么办

• 一些封装中没有串口，或者串口已经被用作其他用途，要如何输出log 

下文来讨论这些问题。

1、输出log信息到SRAM

准确来说这里并不是输出log，而是以一种方式不使用串口就可以看到log。在芯片开发阶段都可以连接仿真器调试，可以使用打断点的方法调试，但是有些操作如果不能被打断就没法使用断点调试了。

这时候可以考虑将log打印到SRAM中，整个操作结束后再通过仿真器查看SRAM中的log buffer，这样就实现了间接的log输出。

本文使用的测试平台是STM32F407 discovery，基于usb host实验代码，对于其他嵌入式平台原理也是通用的。首先定义一个结构体用于打印log，如下:

定义一段SRAM空间作为log buffer:

static u8 log_buffer[LOG_MAX_LEN];

log buffer是环形缓冲区，在小的buffer就可以无限打印log，缺点也很明显，如果log没有及时输出就会被新的覆盖。Buffer大小根据SRAM大小分配，这里使用1kB。为了方便输出参数，使用printf函数来格式化输出，需要做如下配置（Keil）：

并包含头文件#include <stdio.h>, 在代码中实现函数fputc()：

写入数据到SRAM：

为了方便控制log打印格式，在头文件中再添加自定义的打印函数。

在需要打印log的地方直接调用DEBUG()即可，最终效果如下，从Memory窗口可以看到打印的log：

2、通过SWO输出log

通过打印log到SRAM的方式可以看到log，但是数据量多的时候可能来不及查看就被覆盖了。为了解决这个问题，可以使用St-link的SWO输出log，这样就不用担心log被覆盖。查看原理图f407 discovery的SWO已经连接了，否则需要自己飞线连接：

在log结构体中添加SWO的操作函数集：

typedef struct
{
    u8 (*init)(void* arg);
    u8 (*print)(u8 ch);
    u8 (*print_dma)(u8* buffer, u32 len);
}log_func;

typedef struct 
{
    volatile u8     type;
    u8*             buffer;
    volatile u32    write_idx;
    volatile u32    read_idx;
    //SWO
    log_func*       swo_log_func;
}log_dev;

SWO只需要print操作函数，实现如下：

u8 swo_print_ch(u8 ch)
{
    ITM_SendChar(ch);
    return 0;
}

使用SWO输出log同样先输出到log buffer，然后在系统空闲时再输出，当然也可以直接输出。log延迟输出会影响log的实时性，而直接输出会影响到对时间敏感的代码运行，所以如何取舍取决于需要输出log的情形。

在while循环中调用output_ch()函数，就可以实现在系统空闲时输出log。

/*output log buffer to I/O*/
void output_ch(void)
{   
    u8 ch;
    volatile u32 tmp_write,tmp_read;
    tmp_write = log_dev_ptr->write_idx;
    tmp_read = log_dev_ptr->read_idx;

    if(tmp_write != tmp_read)
    {
        ch = log_dev_ptr->buffer[tmp_read++];
        //swo
        if(log_dev_ptr->swo_log_func)
            log_dev_ptr->swo_log_func->print(ch);
        if(tmp_read >= LOG_MAX_LEN)
        {
            log_dev_ptr->read_idx = 0;
        }
        else
        {
            log_dev_ptr->read_idx = tmp_read;
        }
    }
}

2.1 通过IDE输出

使用IDE中SWO输出功能需要做如下配置（Keil）：

在窗口可以看到输出的log：

2.2 通过STM32 ST-LINK Utility输出

使用STM32 ST-LINK Utility不需要做特别的设置，直接打开ST-LINK菜单下的Printf via SWO viewer，然后按start：

3、通过串口输出log

以上都是在串口log暂时无法使用，或者只是临时用一下的方法，而适合长期使用的还是需要通过串口输出log，毕竟大部分时候没法连接仿真器。添加串口输出log只需要添加串口的操作函数集即可：

typedef struct 
{
    volatile u8     type;
    u8*             buffer;
    volatile u32    write_idx;
    volatile u32    read_idx;
    volatile u32    dma_read_idx;
    //uart
    log_func*       uart_log_func;
    //SWO
    log_func*       swo_log_func;
}log_dev;

实现串口驱动函数：

添加串口输出log与通过SWO过程类似，不再多叙述。而下面要讨论的问题是，串口的速率较低，输出数据需要较长时间，严重影响系统运行。

虽然可以通过先打印到SRAM再延时输出的办法来减轻影响，但是如果系统中断频繁，或者需要做耗时运算，则可能会丢失log。要解决这个问题，就是要解决CPU与输出数据到串口同时进行的问题，嵌入式工程师立马可以想到DMA正是好的解决途径。

使用DMA搬运log数据到串口输出，同时又不影响CPU运行，这样就可以解决输出串口log耗时影响系统的问题。串口及DMA初始化函数如下：

u8 uart_log_init(void* arg)
{
    DMA_InitTypeDef DMA_InitStructure;
    u32* bound = (u32*)arg;
    //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//使能USART2时钟
    //串口2对应引脚复用映射
    GPIO_PinAFConfig(GPIOA,GPIO_PinSource2,GPIO_AF_USART2);
    //USART2端口配置
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    GPIO_Init(GPIOA,&GPIO_InitStructure);
    //USART2初始化设置
    USART_InitStructure.USART_BaudRate = *bound;//波特率设置
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    USART_InitStructure.USART_Mode = USART_Mode_Tx; //收发模式
    USART_Init(USART2, &USART_InitStructure); //初始化串口1
    #ifdef LOG_UART_DMA_EN  
    USART_DMACmd(USART2,USART_DMAReq_Tx,ENABLE);
    #endif  
    USART_Cmd(USART2, ENABLE);  //使能串口1 
    USART_ClearFlag(USART2, USART_FLAG_TC);
    while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
    #ifdef LOG_UART_DMA_EN
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    //Config DMA channel, uart2 TX usb DMA1 Stream6 Channel
    DMA_DeInit(DMA1_Stream6);
    DMA_InitStructure.DMA_Channel = DMA_Channel_4;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART2->DR);
    DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; 
    DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    DMA_Init(DMA1_Stream6, &DMA_InitStructure);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    #endif
    return 0;
}

DMA输出到串口的函数如下：

这里为了方便直接使用了查询DMA状态寄存器，有需要可以修改为DMA中断方式，查Datasheet可以找到串口2使用DMA1 channel4的stream6：

最后在PC端串口助手可以看到log输出：

使用DMA搬运log buffer中数据到串口，同时CPU可以处理其他事情，这种方式对系统影响最小，并且输出log及时，是实际使用中用的最多的方式。并且不仅可以用串口，其他可以用DMA操作的接口（如SPI、USB）都可以使用这种方法来打印log。

4、使用IO口模拟串口输出log

最后要讨论的是在一些封装中没有串口，或者串口已经被用作其他用途时如何输出log，这时可以找一个空闲的普通IO，模拟UART协议输出log到上位机的串口工具。常用的UART协议如下：

只要在确定的时间在IO上输出高低电平就可以模拟出波形，这个确定的时间就是串口波特率。为了得到精确延时，这里使用TIM4定时器产生1us的延时。注意：定时器不能重复用，在测试工程中TIM2、3都被用了，如果重复用就错乱了。初始化函数如下：

u8 simu_log_init(void* arg)
{
    TIM_TimeBaseInitTypeDef TIM_InitStructure;  
    u32* bound = (u32*)arg;
    //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    GPIO_Init(GPIOA,&GPIO_InitStructure);
    GPIO_SetBits(GPIOA, GPIO_Pin_2);
    //Config TIM
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,ENABLE); //使能TIM4时钟
    TIM_DeInit(TIM4);
    TIM_InitStructure.TIM_Prescaler = 1;        //2分频
    TIM_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_InitStructure.TIM_Period = 41;          //1us timer
    TIM_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInit(TIM4, &TIM_InitStructure);
    TIM_ClearFlag(TIM4, TIM_FLAG_Update);
    baud_delay = 1000000/(*bound);          //根据波特率计算每个bit延时
    return 0;
}

使用定时器的delay函数为：

最后是模拟输出函数，注意：输出前必须要关闭中断，一个byte输出完再打开，否则会出现乱码：

u8 simu_print_ch(u8 ch)
{
    volatile u8 i=8;
    __asm("cpsid i");
    //start bit
    GPIO_ResetBits(GPIOA, GPIO_Pin_2);
    simu_delay(baud_delay);
    while(i--)
    {
        if(ch & 0x01)
        GPIO_SetBits(GPIOA, GPIO_Pin_2);
        else
        GPIO_ResetBits(GPIOA, GPIO_Pin_2);
        ch >>= 1;
        simu_delay(baud_delay);
    }
    //stop bit
    GPIO_SetBits(GPIOA, GPIO_Pin_2);
    simu_delay(baud_delay);
    simu_delay(baud_delay);
    __asm("cpsie i");
    return 0;
}

使用IO模拟可以达到与真实串口类似的效果，并且只需要一个普通IO，在小封装芯片上比较使用。

NorthFrame是基于非UML极简理念的状态机框架

配合NF_FsmDesigner图形化开发工具，可无负担替代传统switch-case状态机开发。

1、NorthFrame的组件

• NF_FSM :

  极简非UML状态机框架

• NF_FsmDesigner :

  基于C# Winform开发的状态机图形化开发工具，可直接生成C代码

• NF_Signal :

  用于代替全局变量的动态信号机制

NF_Signal ：代替全局变量，使用方便：

NF_Signal_Set("flag_connect", 1);
NF_Signal_Set("blink_cnt", 3);
NF_SignalValue flag_connect = NF_Signal_Get("flag_connect");

2、NorthFrame图形化状态机开发

以下例程在VS2012环境中运行一个判断QE组合键的状态机：

Step1 : 使用NF_FsmDesigner工具设计绘制状态转换图，并保存为XML文件

Step2 : 点击生成代码，生成如下C语言代码

#include <n_frame.h>
#include <fsm_qande.h>

/* 转换执行的外部函数声明 */
extern void IDLE_TO_Q(void);
extern void Q_TO_QE(void);
extern void QE_TO_IDLE(void);
extern void QE_TO_Q(void);
extern void Q_TO_IDLE(void);

/* 状态处理函数声明 */
void FSM_QandE_IDLE(NF_FSM* me, NF_Event event);
void FSM_QandE_Q_DOWN(NF_FSM* me, NF_Event event);
void FSM_QandE_QE_DOWN(NF_FSM* me, NF_Event event);

/* 状态机对象 */
NF_FSM FSM_QandE = {
    FSM_QandE_IDLE
};

/* IDLE状态处理函数 */
void FSM_QandE_IDLE(NF_FSM* me, NF_Event event)
{

    if (NF_FSM_NameIs(event.Name, "Q_DOWN"))
    {
        IDLE_TO_Q();
        NF_FSM_TRAN(FSM_QandE_Q_DOWN);
        return ;
    }

    if (NF_FSM_NameIs(event.Name, "test"))
    {
        NF_FSM_TRAN(FSM_QandE_IDLE);
        return ;
    }
}

/* Q_DOWN状态处理函数 */
void FSM_QandE_Q_DOWN(NF_FSM* me, NF_Event event)
{

    if (NF_FSM_NameIs(event.Name, "E_DOWN"))
    {
        Q_TO_QE();
        NF_FSM_TRAN(FSM_QandE_QE_DOWN);
        return ;
    }

    if (NF_FSM_NameIs(event.Name, "Q_UP"))
    {
        Q_TO_IDLE();
        NF_FSM_TRAN(FSM_QandE_IDLE);
        return ;
    }
}

/* QE_DOWN状态处理函数 */
void FSM_QandE_QE_DOWN(NF_FSM* me, NF_Event event)
{

    if (NF_FSM_NameIs(event.Name, "Q_UP"))
    {
        QE_TO_IDLE();
        NF_FSM_TRAN(FSM_QandE_IDLE);
        return ;
    }

    if (NF_FSM_NameIs(event.Name, "E_UP"))
    {
        QE_TO_Q();
        NF_FSM_TRAN(FSM_QandE_Q_DOWN);
        return ;
    }
}

Step3 : 在main.c文件中实现按键处理，并发送事件给状态机

备注 : 后续版本会加入发布-订阅机制，目前仅支持直接派发

#include "n_frame.h"

#include "windows.h"
#include "stdio.h"

#include "fsm_qande.h"

#define KEY_VALUE(_key) ((GetKeyState(_key) >= 0) ? NF_Bool_False : NF_Bool_True )

/* 信号产生者 */
void Test_Key_Process(void)
{
 static NF_Bool last_q_val = NF_Bool_False;
 static NF_Bool last_e_val = NF_Bool_False;

 NF_Bool then_q_val;
 NF_Bool then_e_val;

 then_q_val = KEY_VALUE('Q');
 then_e_val = KEY_VALUE('E');

 /* Q键事件处理 */
 if ((last_q_val == NF_Bool_False) && (KEY_VALUE('Q') == NF_Bool_True))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("Q_DOWN"));
 } 
 else if ((last_q_val == NF_Bool_True) && (KEY_VALUE('Q') == NF_Bool_False))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("Q_UP"));
 }

 /* E键事件处理 */
 if ((last_e_val == NF_Bool_False) && (KEY_VALUE('E') == NF_Bool_True))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("E_DOWN"));
 } 
 else if ((last_e_val == NF_Bool_True) && (KEY_VALUE('E') == NF_Bool_False))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("E_UP"));
 }

 last_q_val = then_q_val;
 last_e_val = then_e_val;
}

void IDLE_TO_Q(void)
{
 printf("state translate : IDLE -> Q_DOWN\n");
}

void Q_TO_QE(void)
{
 printf("state translate : Q_DOWN -> QE_DOWN\n");
}

void QE_TO_IDLE(void)
{
 printf("state translate : QE_DOWN -> IDLE\n");
}

void QE_TO_Q(void)
{
 printf("state translate : QE_DOWN -> Q_DOWN\n");
}

void Q_TO_IDLE(void)
{
 printf("state translate : Q_DOWN -> IDLE\n");
}

int main(void)
{
 for (;;)
 {
  Test_Key_Process();
 }
}

克隆链接：

git clone https://gitee.com/PISCES_X/NorthFrame.git

在编写单片机程序的时候，由于中断服务程序写的不好，导致单片机程序总是跑飞，最后费了好长时间，花了很大功夫才找到问题原因，由此总结了单片机程序跑飞的三种现象、原因及解决方法。

1、数组越界/溢出

现象：

单片机程序在函数中运行时，总是在运行到函数末尾，要跳出函数时，程序跑飞。

原因：

数组越界（数组溢出），函数中定义的数组元素的个数小于程序中实际使用的数组元素的个数，例如在函数中定义了一个数组ucDataBuff[10]，这个数组只有10个元素，但是在函数中却有这样的语句ucDataBuff[10]=0x1a,这个语句是给数组的第11个元素赋值，：由于定义的数组只有10个元素，从而导致赋值语句中不知道把0x1a放到什么地方，从而导致程序跑飞。

解决方法：

如果在调试程序时，发现程序总是在函数执行完毕时跑飞，多数情况是发生了数组越界（数组溢出）的错误，仔细检查函数中调用的数组是否存在越界（溢出）的情况。

2、中断服务程序缺失

现象：

程序运行过程中总是跑飞。

原因：

程序中打开了某个中断，但是却没有相应的中断服务程序，从而导致在中断发生后，找不到中断服务程序入口，从而导致程序跑飞。

解决方法：

检查程序中是否存在打开了某个中断，但是没有相对应的中断服务程序。

3、看门狗复位

现象：

在执行一段较为耗费时间的程序时，程序跑飞，并且总是跳到复位位置处。

原因：

程序中使用了看门狗，但是没有及时“喂狗”，从而导致看门狗复位，使程序直接跳到复位位置。

解决方法：

根据程序运行时间，尤其是一定要计算清楚最耗时的那段程序的运行时间，然后准确设置看门狗的复位时长，定时“喂狗”，尤其是如果有死循环的情况，一定要在死循环中记得“喂狗”。