什么是有限状态机

75 阅读 0 评论 50 点赞

我是靠谱客的博主精明乐曲，这篇文章主要介绍什么是有限状态机，现在分享给大家，希望可以做个参考。

前言

大家好，我是阿辉。

今天咱们来一起学习有限状态机，在博主日常的工作中，难免会和硬件打交道，比如实时读取设备中的采集数据，接收硬件发送来的采集参数，采集响应命令等。

很多时候会采用有限状态机模型来确保接收数据的完整性。那么接下来让我们一起来看看什么是有限状态机。

什么是有限状态机

比较官方的说法是：有限状态机是一种用来进行对象行为建模的工具，作用是描述对象在它的生命周期内所经历的状态序列，以及如何响应来自外界的各种事件。

在计算机中，有限状态机被应用于建模应用行为，硬件电路系统设置，软件工程，编译器，网络协议和计算与语言的研究。

计算机中经典的有限状态机

说点白话，其实有限状态机就是一种确保在某种状态满足某些条件下的一种处理机制，比如在数据流的接收过程中，根据特定的协议，当数据字节到达某个标志时才算成功接收完所有数据，继而才可以去解析显示。否则就会出现解析失败。

所谓有限状态机就是决定我们程序对象的当前状态和状态间的切换，状态机最终只能指向一个结果，由这个结果指向这个状态的行为，也就是执行的函数。

官方解释下：
有限状态机(Finite State Machine)，任意时刻都处于有限状态集合中的某一状态。当其获得一个输入字符时，将从当前状态转换到另一个状态或者仍然保持当前状态。

总共有三种状态：消亡状态、起始状态、结束状态。

启动一个有限状态机时，首先必须处理“起始状态”，然后根据输入的状态字符，有限状态机制会到达结束状态或者消亡状态。

有限状态机有哪些特点

1、可以确保接收数据的准确性，防止数据丢失。

2、对于解析流程的高度一致，当数据完整时不会出现解析出错的情况。

3、多用于程序的状态管理，实现后易于阅读和理解。

4、系统具有有限个状态，不同的状态代表不同的含义。

5、每个状态之间根据输入的特殊条件可以进行转换。

Demo

在日常工作中，有时候会下位机硬件设备发送的检测数据。那么上位机程序就得根据特定的协议进行解析，输出显示检测数据信息。那么我们来看下是如何解析的。

假如协议规定如下：
AA BB xx xx xx xx xx xx CC DD

可以看到协议头为AA BB，尾部为CC DD 协议总长10字节，数据长为6个字节。

复制代码

/// <summary>
        /// 有效状态机
        /// </summary>
        static void StateJudge(byte currentByte)
        {
            switch (currentState)
            {
                case 0:
                    receivedBytes.Clear();
                    dataCount = 0;

if (currentByte == (byte)0xAA)
                    {
                        currentState++;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    break;
                case 1:
                    if (currentByte == (byte)0xBB)
                    {
                        currentState++;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    currentState = 0;
                    break;
                case 2:
                    if (dataCount < 6)
                    {
                        ++dataCount;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    if (currentByte == (byte)0xCC)
                    {
                        currentState++;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    currentState = 0;
                    break;                
                case 3:
                    if (currentByte == (byte)0xDD)
                    {                        
                        receivedBytes.Add(currentByte);
                        AnalysisData(receivedBytes.ToArray());                        
                    }
                    currentState = 0;
                    dataCount = 0;
                    break;                    
                default:
                    currentState = 0;
                    dataCount = 0;
                    break;
            }
        }

/// <summary>
        /// 解析数据
        /// </summary>
        /// <param name="fullDataStream">完整的数据流</param>
        static void AnalysisData(byte[] fullDataStream)
        {
            Console.WriteLine("");
            Console.WriteLine("输出完整的数据流");
            for (int i = 0; i < fullDataStream.Length; i++)
            {
                Console.Write(fullDataStream[i] + ",");
            }            
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
        /// <summary>
        /// 有效状态机
        /// </summary>
        static void StateJudge(byte currentByte)
        {
            switch (currentState)
            {
                case 0:
                    receivedBytes.Clear();
                    dataCount = 0;

                    if (currentByte == (byte)0xAA)
                    {
                        currentState++;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    break;
                case 1:
                    if (currentByte == (byte)0xBB)
                    {
                        currentState++;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    currentState = 0;
                    break;
                case 2:
                    if (dataCount < 6)
                    {
                        ++dataCount;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    if (currentByte == (byte)0xCC)
                    {
                        currentState++;
                        receivedBytes.Add(currentByte);
                        break;
                    }
                    currentState = 0;
                    break;                
                case 3:
                    if (currentByte == (byte)0xDD)
                    {                        
                        receivedBytes.Add(currentByte);
                        AnalysisData(receivedBytes.ToArray());                        
                    }
                    currentState = 0;
                    dataCount = 0;
                    break;                    
                default:
                    currentState = 0;
                    dataCount = 0;
                    break;
            }
        }

        /// <summary>
        /// 解析数据
        /// </summary>
        /// <param name="fullDataStream">完整的数据流</param>
        static void AnalysisData(byte[] fullDataStream)
        {
            Console.WriteLine("");
            Console.WriteLine("输出完整的数据流");
            for (int i = 0; i < fullDataStream.Length; i++)
            {
                Console.Write(fullDataStream[i] + ",");
            }            
        }

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
        /// <summary>
        /// 当前状态
        /// </summary>
        static int currentState = 0;
        static int dataCount = 0;
        static List<byte> receivedBytes = new List<byte>();

        static void Main(string[] args)
        {
            //解析 下位机发送的数据
            // AA BB xx xx xx xx xx xx CC DD
            byte[] tempCollectData = new byte[] { 0xAA, 0xBB, 0xdc, 0xea, 0xed, 0xef, 0xea, 0x30, 0xCC, 0xDD };
            Console.WriteLine("输入的数据:");
            for (int i = 0; i < tempCollectData.Length; i++)
            {
                Console.Write(tempCollectData[i] + ",");
            }
            for (int i = 0; i < tempCollectData.Length; i++)
            {
                byte entityByte = tempCollectData[i];
                StateJudge(entityByte);
            }
            Console.ReadKey();
        }