单片机 – Blanboom

有限状态机在单片机编程中的应用

Blanboom — Fri, 06 Feb 2015 14:02:03 +0000

在单片机编程中，如果在不使用操作系统的情况下同时执行多个任务，可能会遇到下面这些情况：

一个任务的执行时间过长，导致其他任务无法及时执行
在一些任务中大量使用 delay() 等函数进行软件延时，这些延时函数占用过多时间，影响其他任务的执行
一些复杂任务的程序逻辑不清晰，不便于以后对程序进行维护，或添加新功能

本文介绍的有限状态机，可以做到将一个耗时较长的复杂任务分解为多个简单任务，同时使代码逻辑更加清晰，从而解决上述问题。

目录：

1. 什么是有限状态机
2. 有限状态机的作用
3. 有限状态机的实现
4. 示例一：按键去抖动程序的优化
- 4.1 传统的按键去抖动程序
- 4.2 优化后的按键去抖动程序
5. 示例二：通过有限状态机实现的闹钟程序
6. 后记

1. 什么是有限状态机

根据维基百科上的定义，有限状态机（finite-state machine, FSM，简称状态机）是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。¹

为了理解这句话，假设自己还有三天就要考试，这时候就要进入紧张的备考状态，将空闲时间用在复习上。但是，为了保证足够的精力，小睡一会儿也是十分有必要的。那么，什么时候复习，什么时候睡觉呢？可以这样描述：

在复习的时候：

如果感到瞌睡，则睡觉

如果没有感觉到瞌睡，则继续复习

在小睡的时候：

如果感觉不再瞌睡，则开始复习

如果感觉依旧瞌睡，则继续睡觉

也可通过一幅简单的示意图（也叫「状态转移图」）表示出来：

这个例子其实就是一个简单的有限状态机，其中，复习和小睡是两个状态，感觉瞌睡和感觉清醒这两个条件可以使状态发生转换。²

另外，Programming Basics³ 网站上也提供了状态机相关的教程，用形象化的图片解释了什么是有限状态机，可通过此链接访问。

在嵌入式程序设计中，如果一个系统需要处理一系列连续发生的任务，或在不同的模式下对输入进行不同的处理，常常使用有限状态机实现。例如测量、监测、控制等控制逻辑型应用。⁴

2. 有限状态机的作用

2.1 分解耗时过长的任务

大家应该都知道，CPU 没有并行执行任务的能力。计算机「同时」运行多个程序，其实是多个程序依次交替执行，给人以程序同时运行的错觉。各个程序在什么时候开始执行，执行多长时间后切换到下一个程序，由操作系统决定。

单片机执行多任务也是类似的过程，但由于其资源有限，为了节省对 CPU 和存储空间的占用，在很多情况下没有使用操作系统。这时，单片机中运行的各个任务必须在一定时间内主动执行完毕，才能保证下一个任务能够及时执行。

对于一些需要长时间执行的任务，例如按键去除抖动、读取和播放 MP3 文件等，采用有限状态机的方式，将任务划分为多个小的步骤（状态），每次只执行其中的一步。这样，其他任务就有机会「插入」到这个任务之中，确保了各个任务都能按时执行。

2.2 避免软件延时对 CPU 资源造成浪费

对于一些简单的程序，可通过 delay(), delay_ms() 之类的函数进行软件延时。这些延时函数，一般是通过将某个变量循环递加或递加，到达一定值后跳出循环，从而通过消耗 CPU 时间实现了延时。

这种方式虽然简单，但在延时函数执行的过程中，其他程序无法运行，消耗了大量 CPU 资源。而通过状态机，有助于减少软件延时的使用，提高 CPU 利用率。

请参考下文中的 示例一：按键去抖动程序的优化，这一例子展示了如何通过软件延时分解耗时较长的任务，同时减少软件延时的使用。

2.3 使程序逻辑更加清晰

通过状态机，将一个复杂任务划分为多个状态，可以使程序清晰易懂，便于维护。以后想要添加、删除程序中的功能，都会变得非常容易。

下文中的 示例二：通过状态机实现的闹钟 展示了如何通过状态机优化程序逻辑。

3. 有限状态机的实现

3.1 通过 switch – case 语句实现

如果使用 C 语言，switch – case 语句，即可简单地实现有限状态机。

/* 定义各个状态所对应的数值 */
#define STATUS_A 0
#define STATUS_B 1
#define STATUS_C 2

/* 该变量的值即为当前状态机所处的状态 */
uint8_t currentStatus = STATUS_A;

/* 通过状态机实现的某个任务，
 * 需要放入 while(1) 等地方循环执行
 * /
void fsm_app(void)
{
    switch(currentStatus) /* 根据现在的状态执行相应的程序 */
    {
    case STATUS_A:  /* 状态 A */
        doThingsForStatusA(); /* 执行状态 A 中需要执行的任务 */
        /* 若满足状态转换的条件，则转换到另一个状态 */
        if(condition_1){ currentStatus = STATUE_B; }
        break;
    case STATUS_B:  /* 状态 B */
        doThingsForStatusB(); /* 执行状态 B 中需要执行的任务 */
        /* 若满足状态转换的条件，则转换到另一个状态 */
        if(condition_2){ currentStatus = STATUE_C; }
        if(condition_3){ currentStatus = STATUE_A; }
        break;
    case STATUS_C:  /* 状态 C */
        doThingsForStatusB(); /* 执行状态 B 中需要执行的任务 */
        /* 若满足状态转换的条件，则转换到另一个状态 */
        if(condition_4){ currentStatus = STATUE_A; }
        break;
    default:
        currentStatus = STATUE_A;
    }
}

通过这段程序，即可实现一个具有三个状态的状态机。状态转移图如下图所示：

3.2 通过 Arduino 库实现

对于 Arduino 用户，还可以使用 FSM Library 实现。这一库将有限状态机进行了封装，可以以更简洁的方式实现状态机。

下载地址及使用说明：http://playground.arduino.cc/Code/FiniteStateMachine

3.3 其他方式

对于一些更复杂的任务，使用 switch – case 语句，代码可能会太简洁。这时候，使用其他方式实现状态机，可能会更好。具体请查阅相关资料。

4. 示例一：按键去抖动程序的优化

4.1 传统的按键去抖动程序

初学单片机时，我们接触的按键去抖动程序一般是这样的⁵：

void keyscan()
{
    if(key1 == 0)         // 如果按键 1 按下
    {
        delayms(10);      // 延时 10ms，消除因干扰产生的抖动
            if(key1 == 0) // 再次检测按键 1，如果依旧按下
            {
                doSomething(); //此时说明按键 1 已按下，执行按键 1 需要执行的任务
                while(!key1);  // 等待按键释放
            }
    }
}

对应的流程图如下：

从流程图中可知，delayms() 延时函数和最后的等待按键释放的程序，会占用过多时间。

4.2 优化后的按键去抖动程序

如果使用有限状态机的思路，可以按照下图方式实现：

该状态机有三个状态，分别是按键未按下，等待，按键按下。当按键按下时，则会进入等待状态，若在等待状态中按键一直保持按下，说明按键已经稳定地按下，进入按键按下的状态，等待按键释放。程序代码如下：

/* 按键去抖动状态机中的三个状态 */
#define KEY_STATE_RELEASE    // 按键未按下
#define KEY_STATE_WAITING    // 等待（消抖）
#define KEY_STATE_PRESSED    // 按键按下（等待释放）

/* 等待状态持续时间
 * 需要根据单片机速度和按键消抖程序被调用的速度来进行调整
 */
#define DURIATION_TIME 40

/* 按键检测函数的返回值，按下为 1，未按下为 0 */
#define PRESSED 1
#define NOT_PRESSED 0

/* 按键扫描程序所处的状态
 * 初始状态为：按键按下（KEY_STATE_RELEASE）
 */
uint8_t keyState = KEY_STATE_RELEASE;

/* 按键检测函数，通过有限状态机实现
 * 函数在从等待状态转换到按键按下状态时返回 PRESSED，代表按键已被触发
 * 其他情况返回 NOT_PRESSED
 */
uint8_t keyDetect(void)
{
    static uint8_t duriation;  // 用于在等待状态中计数
    switch(keyState)
    {
    case KEY_STATE_RELEASE:
        if(readKey() == 1)     // 如果按键按下
        {
            keyState = KEY_STATE_WAITING;  // 转换至下一个状态
        }
        return NOT_PRESSED;    // 返回：按键未按下
        break;
    case KEY_STATE_WAITING:
        if(readKey() == 1)     // 如果按键按下
        {
            duriation++;
            if(duriation >= DURIATION_TIME)    // 如果经过多次检测，按键仍然按下
            {   // 说明没有抖动了，可以确定按键已按下
                duriation = 0;
                keyState = KEY_STATE_PRESSED;  // 转换至下一个状态
                return PRESSED;
            }
        }
        else  // 如果此时按键松开
        {   // 可能存在抖动或干扰
            duriation = 0;  // 清零的目的是便于下次重新计数
            keyState = KEY_STATE_RELEASE;  // 重新返回按键松开的状态
            return NOT_PRESSED;
        }
        break;
    case KEY_STATE_PRESSED:
        if(readKey() == 0)       // 如果按键松开
        {
            keyState = KEY_STATE_RELEASE;  // 回到按键松开的状态
        }
        return NOT_PRESSED;
        break;
    default:
        keyState = KEY_STATE_RELEASE;
        return NOT_PRESSED;
    }
}

该程序也可经过扩展，实现判断按键双击、长按等功能。只需增加相应的状态和转移条件即可。

5. 示例二：通过有限状态机实现的闹钟程序

最近正在制作一个闹钟。这个闹钟支持播放 MP3 格式的闹钟声⁶，支持贪睡模式，同时还有一些功能打算以后再添加上。

为了使程序逻辑更加清晰，也为了更方便地添加新功能，我打算采用有限状态机实现。相关程序如下：

#include "App_Alarm.h"
#include "USART1.h"
#include 
#include "diag/Trace.h"

/* 相关常量定义 */
#define ALARM_MUSIC_END 0      // 闹钟音乐播放完毕
#define FORMAT_OK       0      // 格式正确
#define FORMAT_ERROR    (-1)   // 格式错误

/* 输入信息定义
 * 作为函数的返回值供函数 getInput() 使用
 * getInput() 将获取并返回键盘或触摸屏等设备中输入的控制命令或闹钟时间值
 */
#define INPUT_ERROR    (-1)    // 输入格式错误
#define INPUT_CANCEL   (-2)    // 输入了「取消」命令
#define INPUT_SNOOZE   (-3)    // 输入了「小睡」命令
#define INPUT_ALARM_ON (-4)    // 输入了「打开闹钟」命令
#define NO_INPUT       (-10)   // 没有输入

/* 输出信息定义
 * 作为为函数的参数供函数 displayMessege() 使用
 * displayMessege() 用于在显示屏上显示相关的提示信息
 */
#define MESSEGE_SET_ALARM_TIME  (0)  // 提示：设置闹钟时间
#define MESSEGE_CLEAR           (1)  // 提示：已取消
#define MESSEGE_ALARM_IS_ON     (2)  // 提示：闹钟已打开
#define MESSEGE_WAITING         (3)  // 提示：等待闹钟响起
#define MESSEGE_SET_SNOOZE_TIME (4)  // 提示：设置小睡时间
#define MESSEGE_GET_UP          (5)  // 提示：该起床了

/* 闹钟的状态 */
enum alarmStates
{
    ALARM_OFF,              // 闹钟关闭
    SET_ALARM_TIME,         // 设置闹钟时间
    WATING_FOR_ALARM,       // 等待闹钟响起
    PLAY_ALARM_MUSIC,       // 播放闹钟音乐
    SET_SNOOZE_TIME         // 设置贪睡时间
} alarmState = ALARM_OFF;   // 默认状态：闹钟关闭

/* 相关函数的定义 */
int16_t getInput(void);
void displayMessege(uint8_t);
void setAlarm(int16_t);
int16_t alarmTimeDiff(void);
int8_t playAlarmMusic(void);
void setSnooze(int16_t);
uint8_t checkAlarmFormat(int16_t);
uint8_t checkSnoozeFormat(int16_t);

/*
 * 闹钟主程序，需要放入 while(1) 中循环调用
 */
void alarmApp(void)
{
    int16_t input;      // 输入值暂存在这个变量中
    switch (alarmState) // 获取闹钟状态，下面程序将根据闹钟的状态执行相应的任务
    {
    /* 状态：闹钟关闭
     * 在此状态中，将会不断检查是否打开闹钟，如果打开了闹钟，则会进入下一个状态：设置闹钟时间
     */
    case ALARM_OFF:
        if (getInput() == INPUT_ALARM_ON)  // 检查是否打开了闹钟
        {   // 如果打开了闹钟
            displayMessege(MESSEGE_SET_ALARM_TIME); // 在屏幕或串口上提示：请设置闹钟时间
            alarmState = SET_ALARM_TIME;            // 进入下一个状态：设置闹钟时间
        }
        break;
    /* 状态：设置闹钟时间
     * 在此状态中，将会检查输入值，
     * 如果
     *      输入“取消”命令，则取消闹钟设置，返回到闹钟关闭的状态
     *      输入闹钟时间格式错误，则状态不变，等待下一次重新输入
     *      输入了正确的闹钟时间，则设置闹钟，显示闹钟设置成功，并进入下一状态：等待闹钟响起
     */
    case SET_ALARM_TIME:
        input = getInput();         // 获取输入值
        if(input == INPUT_CANCEL)   // 如果输入了“取消”
        {
            displayMessege(MESSEGE_CLEAR);  // 显示“已取消”
            alarmState = ALARM_OFF;         // 进入状态：关闭闹钟
        }
        else if(checkAlarmFormat(input) == FORMAT_OK)   // 如果输入格式正确
        {
            displayMessege(MESSEGE_ALARM_IS_ON); // 显示“成功设置闹钟，闹钟已启动”
            setAlarm(input); // 根据输入值设置闹钟
            alarmState = WATING_FOR_ALARM; // 进入下一状态：等待闹钟响起
        }
        break;
    /* 状态：等待闹钟响起
     * 在此状态中，将会检查是否到达闹钟时间，如果到达，则进入下一状态：播放闹钟音乐
     * 同时，在此状态中也会检查输入，如果输入了“取消”的命令，则进入闹钟关闭的状态
     */
    case WATING_FOR_ALARM:
        displayMessege(MESSEGE_WAITING); // 显示等待闹钟响起的信息，例如离闹钟响起还有多长时间
        if (alarmTimeDiff() <= 0) // 检查离闹钟响起还有多少时间，如果时间小于等于零（到达闹钟时间）
        {
            alarmState = PLAY_ALARM_MUSIC;  // 进入下一个状态：播放闹钟音乐
        }
        if(getInput() == INPUT_CANCEL) // 如果输入了“取消”命令
        {
            displayMessege(MESSEGE_CLEAR);
            alarmState = ALARM_OFF;      // 进入闹钟关闭的状态
        }
        break;
    /* 状态：播放闹钟音乐
     * 在此状态中，将播放闹钟音乐，若播放完毕，进入闹钟关闭的状态
     * 同时，在此状态中也会检查输入，
     *      如果输入了“小睡”的命令，则进入状态：设置小睡时间
     *      如果输入了“取消”的命令，则进入状态：闹钟关闭
     */
    case PLAY_ALARM_MUSIC:
        displayMessege(MESSEGE_GET_UP);  // 显示消息：“该起床了”
        if(playAlarmMusic() == ALARM_MUSIC_END) // 播放闹钟音乐
        { // 若音乐播放完毕
            displayMessege(MESSEGE_CLEAR);
            alarmState = ALARM_OFF; // 进入状态：闹钟关闭
        }
        input = getInput();
        if(input == INPUT_SNOOZE) // 若输入了“小睡”的命令
        {
            displayMessege(MESSEGE_SET_SNOOZE_TIME); // 显示消息：“请设置小睡时间”
            alarmState = SET_SNOOZE_TIME; // 进入状态：设置小睡时间
        }
        if(input == INPUT_CANCEL) // 若输入了“取消”命令
        {
            displayMessege(MESSEGE_CLEAR);
            alarmState = ALARM_OFF;   // 进入状态：闹钟关闭
        }
        break;
    /* 状态：设置小睡时间
     * 在此状态中，将从输入获取小睡时间，并将闹钟时间加上小睡时间，进入状态：等待闹钟响起
     */
    case SET_SNOOZE_TIME:
        input = getInput(); // 获取输入
        if(input == INPUT_CANCEL)
        {   // 若输入“取消”，则进入“闹钟关闭”的状态
            displayMessege(MESSEGE_CLEAR);
            alarmState = ALARM_OFF;
        }
        else if(checkSnoozeFormat(input) == FORMAT_OK)
        {   // 若输入格式正确
            setSnooze(input);  // 设置新的闹钟时间
            alarmState = WATING_FOR_ALARM;  // 进入状态：等待闹钟响起
        }
        break;
    default:
        displayMessege(MESSEGE_CLEAR);
        alarmState = ALARM_OFF;
    }
}

状态转移图如图所示：

6. 后记

在单片机编程时，如果遇到代码复杂、任务占用时间过长等问题，可以尝试通过有限状态机解决。

之前写过一个针对 Arduino 的合作式任务调度器。配合有限状态机，更有利于多任务处理。

另外，instructables 上的一篇文章通过三个实例演示了有限状态机在 Arduino 上的应用，如果感兴趣，可以通过这个链接阅读：http://www.instructables.com/id/Arduino-Finite-State-Machine/

备注

[8051学习笔记] 按键双击、连按的检测

Blanboom — Fri, 07 Jun 2013 07:45:33 +0000

昨晚上课时，老师说：“用单片机检测按键的双击，看似简单，但实现起来，需要一点小技巧。”

这句话引起了我的兴趣，我打算自己尝试一下。经过折腾，算是解决了这个问题。

Update(2013.8.3): 最近看了从单片机初学者迈向单片机工程师这个帖子，里面有更合理的方法，值得借鉴。

最初的思路

当判断按键按下后，延时适当时间，再判断一次按键是否按下，如果按下，说明按键双击，如果没按下，说明是单击。

不过，这样做的话，对两次按键的时间间隔有要求，不能过长或过短。实际测试时确实如此，基本上不能正常、稳定地使用。

程序如下：

//51单片机的键盘双击检测，简易版
//程序功能：单击按键灭灯，双击亮灯
//By Blanboom
//https://blanboom.org
//2013.6.6

#include 
#define uint unsigned int
#define uchar unsigned char
sbit LED=P0^4;
sbit KEY=P3^4;

void delay(uint time);       //毫秒级延时子程序

int main()
{   
    LED=0;
    while(1)
    {
        if(KEY==0)              //先判断是否按键
        {
            delay(10);
            if(KEY==0)
            {
                while(!KEY);        
                delay(100);
                if(KEY==0)      //如果按键，则判断是否有第二次按键
                {
                    LED=0;      //如果第二次按键（双击），则灯亮
                }
                else
                {
                    LED=1;       //如果第二次没按键，则灯不亮
                    while(!KEY); //按键松下后才能继续执行。
                    delay(50);   //消除抖动
                }       
            }   
        }
    }           
}

void delay(uint time)             
{
    uint i,j;
    for(i=110;i>0;i--)
        for(j=time;j>0;j--);
}

最终方案

后来，上网找了一些资料，通过判断 每次按键按下之后的一段时间内，判断按键是否再次按下 的方法，把问题解决了：

//51单片机的键盘双击检测，定时器版
//程序功能：单击按键灭灯，双击亮灯
//By Blanboom
//https://blanboom.org
//晶振频率：11.0592M
//2013.6.7

#include 
#define uint unsigned int
#define uchar unsigned char
sbit LED = P0^4;         //LED所连接的IO口
sbit KEY = P3^4;         //按键所连接的IO口
#define KEY_AVALIABLE 0  //值为0时，按键低电平触发；值为1时，按键高电平触发
#define LED_AVALIABLE 0  //值为0时，低电平LED亮；值为1时，高电平LED亮
#define MAX_WAIT_TIME 4  //按键后等待另一次按键的时间，单位：50ms

uint wait_time = 0;      //按键后的等待时间
uchar key_state = 0;     //按键次数

void timer1_initial();   //定时器初始化
void delay(uint time);   //毫秒级延时子程序
uchar key_read();        //按键读取程序

void main()
{
    //LED，按键，定时器的初始化
    LED = LED_AVALIABLE;
    KEY = !KEY_AVALIABLE;
    timer1_initial();  

    while(1)
    {
        uchar key_state_temp;
        key_state_temp = key_read();
        if(key_state_temp == 1)
        {
            LED = !LED_AVALIABLE;       //按键1次，灯灭
        }
        else if(key_state_temp >=2)
        {
            LED = LED_AVALIABLE;        //按键大于1次，灯亮
        }
    }
}

void timer1() interrupt 3       //定时器1：50ms
{
    TH1 = (65536-45872)/256;
    TL1 = (65536-45872)%256;
    wait_time++;
}

void timer1_initial()            //定时器初始化
{
    TH1 = (65536-45872)/256;
    TL1 = (65536-45872)%256;             
    IE = 0x88;                             
    TMOD = 0x10;                     
    TR1 = 1;                         
}

void delay(uint time)
{
    uint i,j;
    for(i=110;i>0;i--)
        for(j=time;j>0;j--);
}

uchar key_read()                         //读取按键,并返回按键次数
{   
    uchar key_state_temp = 0;
    if(KEY == KEY_AVALIABLE)
    {
        delay(10);
        if(KEY == KEY_AVALIABLE);
        {
            while(KEY == KEY_AVALIABLE);
            wait_time = 0;               //按键后重新计时
            key_state++;
        }
    }

    //超过一定时间没按键，函数将返回按键次数
    if(wait_time >= MAX_WAIT_TIME)   
    {
        wait_time = 0;
        key_state_temp = key_state;
        key_state = 0;
    }

    return key_state_temp;
}

实际测试中，这种方法已经能够正常使用了。如果有更好的办法欢迎告诉我。

摇摇棒的更多玩法

Blanboom — Fri, 17 May 2013 07:53:44 +0000

这段时间，我们班、科协和院学生会都组织了摇摇棒制作活动。大概是因为摇摇棒是一项容易制作，而且比较好玩的电子 DIY.

由于摇摇棒里的单片机可以编程，所以，可以通过修改程序，使摇摇棒又更多功能。下面是我的一些想法：

自动调节亮度

加装光敏电阻，或直接通过 LED 获取周围环境亮度，并根据环境亮度自动调节摇摇棒的亮度。

将 LED 用做光线传感器的方法，《爱上单片机》上有简单的介绍。

显示动画

使摇摇棒显示动态的内容。

不过，因为单片机的容量一般都比较小，所以通过一次显示一张张不同的图片的方法来显示动画，可行性不是太高。我感觉通过一些算法，产生简单的矢量动画，应该是一个不错的选择。

摇摇棒时钟

让摇摇棒显示当前时间。

最简单的方式是用进度条的方式显示，类似我做的进度条时钟。也可以在摇动摇摇棒时，显示数字或时钟图形。

CPU、内存指示器

将摇摇棒连接电脑，通过获取电脑的 CPU、内存使用率，并以进度条的形式显示在摇摇棒上。

世界心情指示器

灵感来自此处。

分析、统计 Twitter （世界上最大的微博）中关于心情的词语（Happy, Sad 等），并通过一定的形式显示在摇摇棒的 LED 上。

这是自己最近的一些简单的想法，欢迎大家补充或实践。

[我的DIY]进度条时钟

Blanboom — Fri, 10 May 2013 09:27:47 +0000

这是我和我的同学胡春宇、王哲强正在一起做的一个电子小制作。不过，外形很不好看。

想法

上学期，在科协，学长给了我们一份他搜集到的 DIY 项目，供我们参考并制作。我发现里面的进度条时钟挺漂亮，就和另外两位同学商量，做出一个具有类似功能的时钟。

原先的时钟，是用电动机+蓝色薄膜片制成的。为了增加功能，我们决定用单片机控制。

起初的想法挺多，想到了用液柱，或者荧光管做进度条。可是液柱高低的控制，似乎有点复杂，同时也没有找到合适的荧光管，只好用效果不是很好的LED。

外观上，本想做得十分精简，从正面只能看到进度条，没有多余的按键，电路等全部隐藏在进度条下。这一点最后也因制作过程复杂而放弃。

功能上，我们想出了一大堆，保留下来的也没多少。

所以经过不断地简化，我们的进度条时钟准备做成这样：

采用两块洞洞板，一块做控制板，一块用来显示时间。
具有时钟、闹钟的功能，将来可能加上番茄钟。
通过串口设置时间。可配合蓝牙转 TTL 模块，用手机遥控。

现实

不多说，请看照片：
整体外观

控制板

进度条背面特写，恐怖的飞线（还好没短路）

制作时，板子尺寸没选好，元件位置没仔细安排，做出来之后，就成了这样，毫无美感。

那就暂且先这样做了，就当作我们入门电子 DIY 的练手作品吧。以后有机会，再推出 2.0 版。以后还需要经常时间，在能做出更好的作品。

后记

刚刚看到一个视频，才发现控制水柱不难。我本来还以为要通过压强感应的方式来控制。
这也是别人的一个 DIY，通过液柱高度显示游戏中人物的生命值。效果确实不错。不知道什么时候，我也能把东西做得这么漂亮。

此外，交流过少，没有提前做好计划，也是这次 DIY 中，我们存在的不足之处。