【有限状态机】- FSM详细讲解 【附Autoware有限状态机模型代码讲解】

最新推荐文章于 2024-05-15 10:15:11 发布
最新推荐文章于 2024-05-15 10:15:11 发布
阅读量1.9k 收藏 28
点赞数 33
分类专栏： Motion planning 决策规划控制 文章标签： FSM 有限状态机 状态模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigDavid123/article/details/137076757
版权

参考博客：
（1）FSM（有限状态机）
（2）关于有限状态机(FSM)的一些思考
（3）状态设计模式

1 状态机简介

有限状态机FSM：有限个状态以及在这些状态之间的转移和动作等行为的数学模型。

状态机思维：将一个事件分成多个完整的状态，每个状态通过输入和输出进入下一个状态。

优点：可以把模型的多状态和多状态之间的转换条件解耦，降低程序耦合度，让程序维护变的更加容易

FSM术语：state、transition、action、transition condition

2 FSM术语

2.1 状态 State

将一件事拆分为多件事，为每一件事赋予一个名字，这个名字就被称为FSM中的状态。因其状态有限，所以FSM被称为有限状态机。

  • 风扇：划分为关、一档、二挡、三挡等状态
  • 电梯门：划分为关闭、正在开启、开启、正在关闭
2.2 状态转移

状态转移：一个状态执行了某些动作转变为另一个状态的过程

2.3 转移条件 Event

在某个状态下，达到了某个转移条件，才会按照状态机的转移流程转移到下一状态，并执行相应的动作

2.4 动作 Action

当转变为一个新状态时，在这个状态下需要做的事情，称为动作

3 有限状态机的实现方式

实现方式适用场景优点缺点
分支逻辑法适用于条件简单，状态固定，没有新增和扩展的需求状态机代码直译，简单直接，状态逻辑比较集中，容易查看对于较复杂的状态机，这种方式容易遗漏或者写错。大量的if-else和switch-case代码分支判断逻辑，可读性和可扩展性比较差，对新增和修改的场景容易引入bug
查表法通过二维数组来表达状态机，适用于复杂状态机，执行动作比较固定和简单的场景，比如游戏这种状态比较多的场景就适合用查表法相对于分支逻辑的实现方式，查表法的代码实现更加清晰，可读性和可维护性更好遇到比较复杂的动作，就无法通过简单的二维数组表示了，有一定的局限性
状态模式对于状态并不多、状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能比较复杂的状态机来说，我们首选这种实现方式代码结构更清晰，可以规避过多的分支逻辑判断，代码可维护性更高状态模式会引入很多状态类，如果状态颗粒度控制不好，会导致状态类爆炸问题；另外逻辑比较分散，集中在状态类中，无法在一个地方整体看出整个状态机的逻辑
3.1 示例FSM

三种状态：未支付、未收货、完成
两种事件：支付、收货
状态的流转即动作：支付后状态为未收货，收货后状态为完成

支付状态枚举

// 支付状态枚举
enum PayState {
	// 待支付
	UNPAY = 0,
	// 待收货
	UNRECEIVE = 1,
	// 完成
	FINAL = 2,
	// 错误
	ERROR = 3,
};

支付事件枚举

// 支付事件枚举
enum PayEvent {
	// 支付
	Pay = 0,
	// 收货
	RECEIVE = 1,
};
3.2 分支逻辑法
#include <iostream>

using namespace std;

// 支付状态枚举
enum PayState {
	// 待支付
	UNPAY = 0,
	// 待收货
	UNRECEIVE = 1,
	// 完成
	FINAL = 2,
	// 错误
	ERROR = 3,
};

// 支付事件枚举
enum PayEvent {
	// 支付
	PAY = 0,
	// 收货
	RECEIVE = 1,
};

class PayStateMachine {
	private:
		PayState payState;
	public:
		PayStateMachine() {
			payState = PayState::UNPAY;
		}
		void executeEvent(PayEvent payEvent) {
			switch (payEvent) {
				// 支付行为发生：未支付 -> 待收货
				case PAY:
					if (this->payState != PayState::UNPAY) {
						cout << "商铺不是【未支付】状态，请核验" << endl;
						this->payState = PayState::ERROR;
						break;
					} 
					this->payState = PayState::UNRECEIVE;
					break;
				// 收货行为发生：待收货 -> 完成
				case RECEIVE:
					if (this->payState != PayState::UNRECEIVE) {
						cout << "商铺不是【未收货】状态，请核验" << endl;
						this->payState = PayState::ERROR;
						break;
					}
					this->payState = PayState::FINAL;
					break;
				default:
					cout << "未设置的行为" << endl;
					break;
			}
		}
		PayState getCurrentState() {
			return this->payState;
		}
};

int main() {
	PayStateMachine payStateMachine;
	cout << "当前状态为：" << payStateMachine.getCurrentState() << endl;
	payStateMachine.executeEvent(PayEvent::RECEIVE);
	cout << "当前状态为：" << payStateMachine.getCurrentState() << endl;
	return 0;
}

运行结果：

当前状态为：0
商铺不是【未收货】状态，请核验
当前状态为：3

3.3 查表法

将状态和事件形成一个二维矩阵表，将结果态放入其中

UNPAYUNRECEIVEFINAL
PAY状态转为UNRECEIVEERRORERROR
RECEIVEERROR状态转为FINALERROR

将结果态转为一个二维数组进行存储，用的时候使用状态和事件枚举的value值作为索引，获取结果态

#include <iostream>
#include <vector>
using namespace std;

// 支付状态枚举
enum PayState {
	// 待支付
	UNPAY = 0,
	// 待收货
	UNRECEIVE = 1,
	// 完成
	FINAL = 2,
	// 错误
	ERROR = 3,
};

// 支付事件枚举
enum PayEvent {
	// 支付
	PAY = 0,
	// 收货
	RECEIVE = 1,
};

class PayStateMachine {
	public:
		// 初始化
		PayStateMachine() {
			currentPayState = PayState::UNPAY;
		}
		// 使用状态和事件枚举的value值作为索引，获取结果态
		void executeEvent(PayEvent payEvent) {
			this->currentPayState = payStateTable[this->currentPayState][payEvent];
		}
		// 获取当前状态
		PayState getCurrentState() {
			return this->currentPayState;	
		}
	private:
		// 当前状态
		PayState currentPayState;
		// 将结果态转为一个二维数组进行存储
		vector<vector<PayState>> payStateTable = {
			{UNRECEIVE, ERROR, ERROR},
        	{ERROR, FINAL, ERROR}
		};
};

int main()
{
	PayStateMachine payStateMachine;
	cout << "当前状态为：" << payStateMachine.getCurrentState() << endl;
	payStateMachine.executeEvent(PayEvent::PAY);
	cout << "当前状态为：" << payStateMachine.getCurrentState() << endl;
	payStateMachine.executeEvent(PayEvent::RECEIVE);
	cout << "当前状态为：" << payStateMachine.getCurrentState() << endl;
	return 0;
}

运行结果：

当前状态为：0
当前状态为：1
当前状态为：2
3.4 状态模式

状态模式，定义状态接口，并将行为规定为抽象方法，实现对应三种状态以及行为方法（实现状态流转逻辑）。

定义状态机，并依赖状态接口。

同时，每个具体的状态又依赖状态机。

即状态机和各个状态类之间是双向依赖关系，因为每个状态需要依靠状态机修改状态

状态模式将每个状态的实现都封装在一个类中，每个状态类的实现相对独立，使得添加新状态或修改现有状态变得更加容易，避免了使用大量的条件语句来控制对象的行为。但是如果状态过多，会导致类的数量增加，可能会使得代码结构复杂。

状态模式基本结构

  • State：定义一个接口，用于封装与Context的一个特定状态相关的行为
  • ConcreteState（具体状态）： 负责处理Context在状态改变时的行为, 每一个具体状态子类实现一个与Context的一个状态相关的行为。
  • Context（上下文）: 维护一个具体状态子类的实例，这个实例定义当前的状态

在这里插入图片描述

#include <iostream>
#include <vector>
#include <string>

// 状态接口
class State {
public:
    virtual std::string handle() = 0;  // 处理状态的方法
};

// 具体状态类
class OnState : public State {
public:
    std::string handle() override {
        return "Light is ON";
    }
};
 
class OffState : public State {
public:
    std::string handle() override {
        return "Light is OFF";
    }
};
 
class BlinkState : public State {
public:
    std::string handle() override {
        return "Light is Blinking";
    }
};
// 上下文类
class Light {
private:
    State* state;  // 当前状态
public:
    Light() : state(new OffState()) {}  // 初始状态为关闭
    void setState(State* newState) {  // 设置新的状态
        delete state;  // 释放之前的状态对象
        state = newState;
    }
    std::string performOperation() {  // 执行当前状态的操作
        return state->handle();
    }
 
    ~Light() {
        delete state;  // 释放内存
    }	
};

int main() {
    // 读取要输入的命令数量
    int n;
    std::cin >> n;
    std::cin.ignore();  // 消耗掉整数后的换行符
 
    // 创建一个Light对象
    Light light;
 
    // 处理用户输入的每个命令
    for (int i = 0; i < n; i++) {
        // 读取命令并去掉首尾空白字符
        std::string command;
        std::getline(std::cin, command);
 
        // 根据命令执行相应的操作
        if (command == "ON") {
            light.setState(new OnState());
        } else if (command == "OFF") {
            light.setState(new OffState());
        } else if (command == "BLINK") {
            light.setState(new BlinkState());
        } else {
            // 处理无效命令
            std::cout << "Invalid command: " << command << std::endl;
        }
 
        // 在每个命令后显示灯的当前状态
        std::cout << light.performOperation() << std::endl;
    }
 
    return 0;
}

4 Autoware有限状态机代码解析

state_machine.h

#ifndef STATE_MACHINE_H
#define STATE_MACHINE_H

#include <memory>
#include <iostream>

namespace state_machine
{
// 定义一个枚举类StateList，表示车辆的不同状态
enum class StateList : int32_t
{
  MOVE_FORWARD,           // 车辆向前移动
  TRAFFIC_LIGHT_STOP,     // 遇到红灯停车
  LANE_CHANGE,            // 车辆变更车道
  STOP_SIGN_STOP,         // 遇到停车标志停车
  OBSTACLE_AVOIDANCE,     // 避障

  MISSION_COMPLETE = 100, // 任务完成
  EMERGENCY = -1,         // 紧急情况 
};
// 定义一个枚举类TrafficLight，表示交通信号灯的状态
enum class TrafficLight : int32_t
{
  RED,     // 红灯
  GREEN,   // 绿灯
  UNKNOWN, // 未知
};
// 定义一个枚举类ChangeFlag，表示车辆变更车道的方向
enum class ChangeFlag : int32_t
{
  straight,     // 直行
  right,        // 向右变更车道
  left,         // 向左变更车道
 
  unknown = -1, // 未知方向
};
// 用于将枚举类类型转换为整数类型
// 可以将枚举类的实例转换为整数类型，便于进行数值计算或其他整数相关的操作
template <class T>
typename std::underlying_type<T>::type enumToInteger(T t)
{
  return static_cast<typename std::underlying_type<T>::type>(t);
}

// Forward Decralation
class StateContext;

// abstract class for states
class BaseState
{
public:
  virtual ~BaseState() = default;                 // 确保子类可以正确地删除基类对象
  virtual void update(StateContext *context) = 0; // 用于更新状态
  virtual int32_t getStateName()                  // 返回当前状态的名称
  {
    return 0;
  };
  
  virtual std::unique_ptr<std::string> getStateNameString() // 返回当前状态的名称字符串
  {
    return 0;
  };
};

// State : MOVE_FORWARD
class StateMoveForward : public BaseState
{
public:
  // 更新状态逻辑
  void update(StateContext *context) override;
  // 获取状态名称（整数表示）
  int32_t getStateName() override
  {
    return enumToInteger(StateList::MOVE_FORWARD);
  }
  // 获取状态名称（字符串表示）
  std::unique_ptr<std::string> getStateNameString() override
  {
    return std::unique_ptr<std::string>(new std::string("MOVE_FORWARD"));
  }
  // 静态方法，用于创建 StateMoveForward 对象
  static std::unique_ptr<BaseState> create()
  {
    return std::unique_ptr<BaseState>(new StateMoveForward);
  };

private:
  StateMoveForward() = default;
};

// State : TRAFFIC_LIGHT_STOP
class StateTrafficLightStop : public BaseState
{
public:
  // 更新状态逻辑
  void update(StateContext *context) override;
  // 获取状态名称（整数表示）
  int32_t getStateName() override
  {
    return enumToInteger(StateList::TRAFFIC_LIGHT_STOP);
  }
  // 获取状态名称（字符串表示）
  std::unique_ptr<std::string> getStateNameString() override
  {
    return std::unique_ptr<std::string>(new std::string("TRAFFIC_LIGHT_STOP"));
  }
  // 静态方法，用于创建 StateTrafficLightStop 对象
  static std::unique_ptr<BaseState> create()
  {
    return std::unique_ptr<BaseState>(new StateTrafficLightStop);
  };

private:
  StateTrafficLightStop() = default;
};

// State : LANE_CHANGE
class StateLaneChange : public BaseState
{
public:
  // 更新状态逻辑
  void update(StateContext *context) override;
  // 获取状态名称（整数表示）
  int32_t getStateName() override
  {
    return enumToInteger(StateList::LANE_CHANGE);
  }
  // 获取状态名称（字符串表示）
  std::unique_ptr<std::string> getStateNameString() override
  {
    return std::unique_ptr<std::string>(new std::string("LANE_CHANGE"));
  }
  // 静态方法，用于创建 StateLaneChange 对象
  static std::unique_ptr<BaseState> create()
  {
    return std::unique_ptr<BaseState>(new StateLaneChange);
  };

private:
  StateLaneChange() = default;
};

// State : STOP_SIGN_STOP
class StateStopSignStop : public BaseState
{
 public:
  // 更新状态逻辑
  void update(StateContext *context) override;
  // 获取状态名称（整数表示）
  int32_t getStateName() override
  {
    return enumToInteger(StateList::STOP_SIGN_STOP);
  }
  // 获取状态名称（字符串表示）
  std::unique_ptr<std::string> getStateNameString() override
  {
    return std::unique_ptr<std::string>(new std::string("STOP_SIGN_STOP"));
  }
  // 静态方法，用于创建StateStopSignStop对象
  static std::unique_ptr<BaseState> create()
  {
    return std::unique_ptr<BaseState>(new StateStopSignStop);
  };

 private:
  StateStopSignStop() = default;
};

// State : Obstacle Avoidance
class StateObstacleAvoidance : public BaseState
{
 public:
  void update(StateContext *context) override;
  int32_t getStateName() override
  {
    return enumToInteger(StateList::STOP_SIGN_STOP);
  }
  std::unique_ptr<std::string> getStateNameString() override
  {
    return std::unique_ptr<std::string>(new std::string("OBSTACLE_AVOIDANCE"));
  }
  static std::unique_ptr<BaseState> create()
  {
    return std::unique_ptr<BaseState>(new StateObstacleAvoidance);
  };

 private:
  StateObstacleAvoidance() = default;
};

// State : EMERGENCY
class StateEmergency : public BaseState
{
public:
  void update(StateContext *context) override;
  int32_t getStateName() override
  {
    return enumToInteger(StateList::EMERGENCY);
  }
  std::unique_ptr<std::string> getStateNameString() override
  {
    return std::unique_ptr<std::string>(new std::string("EMERGENCY"));
  }
  static std::unique_ptr<BaseState> create()
  {
    return std::unique_ptr<BaseState>(new StateEmergency);
  };

private:
  StateEmergency() = default;
};

// State : MISSION_COMPLETE
class StateMissionComplete : public BaseState
{
public:
  void update(StateContext *context) override;
  int32_t getStateName() override
  {
    return enumToInteger(StateList::MISSION_COMPLETE);
  }
  std::unique_ptr<std::string> getStateNameString() override
  {
    return std::unique_ptr<std::string>(new std::string("MISSION_COMPLETE"));
  }
  static std::unique_ptr<BaseState> create()
  {
    return std::unique_ptr<BaseState>(new StateMissionComplete);
  };

private:
  StateMissionComplete() = default;
};
// 包含状态机当前状态的上下文对象，它包含了当前状态、交通灯颜色和车辆变更车道等信息
class StateContext
{
public:
  StateContext()
    : state_(StateMoveForward::create()), light_color_(TrafficLight::UNKNOWN), change_flag_(ChangeFlag::unknown){};
  // 设置状态机当前状态
  void setState(std::unique_ptr<BaseState> newState)
  {
    state_ = std::move(newState);
  };
  // 更新状态机状态
  void update()
  {
    state_->update(this);
  }
  // 设置交通灯颜色
  void setLightColor(const int32_t &msg)
  {
    light_color_ = static_cast<TrafficLight>(msg);
  }
  // 设置变道方向
  void setChangeFlag(const int32_t &msg)
  {
    change_flag_ = static_cast<ChangeFlag>(msg);
  }
  // 获取当前交通灯颜色
  TrafficLight getLightColor() const
  {
    return light_color_;
  }
  // 获取当前变道方向
  ChangeFlag getChangeFlag() const
  {
    return change_flag_;
  }
  // 获取当前状态机的整数表示状态名称
  int32_t getCurrentState() const
  {
    return state_->getStateName();
  }
  // 获取当前状态机的字符串表示状态名称
  std::unique_ptr<std::string> getCurrentStateString() const
  {
    return state_->getStateNameString();
  }

private:
  std::unique_ptr<BaseState> state_;
  TrafficLight light_color_;
  ChangeFlag change_flag_;
};

}  // state_machine
#endif  // STATE_MACHINE_H

state_machine.cpp

#include "state_machine.h"

namespace state_machine
{
void StateTrafficLightStop::update(StateContext *context)
{
  // 如果交通灯颜色为绿色，表示可以继续行驶，将状态机转移到StateMoveForward状态
  if (context->getLightColor() == TrafficLight::GREEN)
    context->setState(StateMoveForward::create());
}

void StateMoveForward::update(StateContext *context)
{
  // 如果交通灯颜色为红色，表示需要停车，将状态机转移到 StateTrafficLightStop 状态
  if (context->getLightColor() == TrafficLight::RED)
    context->setState(StateTrafficLightStop::create());
  // 如果变化标志为右转或左转，将状态机转移到 StateLaneChange 状态
  if(context->getChangeFlag() == ChangeFlag::right || context->getChangeFlag() == ChangeFlag::left)
    context->setState(StateLaneChange::create());
}

void StateLaneChange::update(StateContext *context)
{
  // 如果变化标志为直行，将状态机转移到 StateMoveForward 状态
  if(context->getChangeFlag() == ChangeFlag::straight)
    context->setState(StateMoveForward::create());
}

void StateStopSignStop::update(StateContext *context)
{
  // stop sign stop
}

void StateMissionComplete::update(StateContext *context)
{
  // Mission complete
}

void StateEmergency::update(StateContext *context)
{
  // Emergency
}

void StateObstacleAvoidance::update(StateContext *context)
{
  // Obstacle Avoidance
}

}  // state_machine

有限状态机原理及三种模式代码实现如上，错误之处望读者指正。

Big David
关注
  • 33
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
有限状态机（FSM）的设计与实现
01-30
有限状态机（FSM）是表示有限个状态及在这些状态之间的转移和动作等行为的数学模型，在计算机领域有着广泛的应用。通常FSM包含几个要素：状态的管理、状态的监控、状态的触发、状态触发后引发的动作。本文主要阐述一下状态机的几种设计方法。1：switchcase/ifelse设计方法这种设计方法最简单，通过一大堆判断来处理，适合小规模的状态切换流程，但如果规模扩大难以扩展和维护。2：基于表结构的状态机设计方法：建立相应的状态表和动作查询表，根据状态表、事件、动作表定位相应的动作处理函数，执行完成后再进行状态的切换。一个通用的状态机处理模块的设计如下：假设我们的状态图如下：相应的状态机设置如下：in
自动驾驶Autoware源码
09-11
日本名古屋大学开源的自动驾驶源码：Autoware框架。适合做自动驾驶。
FSM有限状态机-状态图画法
程序的尽头是数学，一日不推导赶不上买买提
09-19 1万+
工具推荐 1 https://www.processon.com/diagrams 2 visio
设计模式：状态模式及有限状态机
qq_43274123的博客
02-04 774
有时候在组件构建的过程中，某些对象的状态经常面临变化，如何对变化进行有效管理的同时又能保证高层模块的稳定。（状态模式解决的问题）即是根据运行时的条件转换状态。 如果不用状态模式，普通开发可能会导致if-else增值过多以及破坏oop原则。 状态模式允许一个对象在内部状态改变它的行为，从而是对象看起来似乎修改了其行为。~GOF设计模式 state模式将所有的行为都放在state的子类对象中，在对象状态切换时，切换相应的对象。而且这样写可以使状态之间的转换更加明确，可以保证不出现状态不一致的情况，即有限状态机值
有限状态机（Finite State Machine，简称FSM）
最新发布
探索未知，成就非凡
05-15 220
首先，需要定义状态机的所有可能状态。这些状态通常用枚举类型来表示，以便于代码的可读性和维护性。} state_t;接下来，需要定义一个寄存器来保存当前状态。
autoware_ros:autoware原始代码注释解析，会进行一些顺手的代码修改
03-23
autoware_ros:autoware原始代码注释解析，会进行一些顺手的代码修改
FSM（有限状态机）
SjiaM的博客
05-11 9506
本文介绍FSM（有限状态机），以及如何引用、解决问题案例
Autoware(Pure pursuit代码学习)
BigDavid123的博客
06-19 2638
pure pursuit只能用于一些简单的场景，如直线道路上的循迹；对于一些复杂的路径如U型/S型等曲线路径跟踪效果较差。根据pure pursuit的原理可以知道，其跟踪效果很大程度上取决于前视距离LdL_{d}Ld​的选择，设置固定的前视距离和路径曲率肯定无法适应不同的路径，因此就需要对前视距离的计算方法进行研究改进。Pure Pursuit 纯追踪法在Autoware中，绿色的球体即为计算的跟踪预瞄点；红色的点为规划好的路径点；白色的轨迹为轨迹跟踪算法计算出的车辆将要运行的轨迹。
有限状态机FSM详解（一）
热门推荐
benjonc的博客
04-09 5万+
有限状态机在维基百科中的解释是： 有限状态机（英语：finite-state machine，缩写：FSM）又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 至于为什么要学FSM，FSM可以把模型的多状态、多状态间的转换条件解耦。可以使维护变得容易，代码也更加具有可读性，也更加艺术。 理解有限状态机首先需要理解整个模型。我们把灯的开关作为示例，...
在FSM模型中使用两态数据类型
小柚子的博客
02-14 346
在FSM模型中使用两态数据类型 1、使用两态类型和枚举类型对FSM复位 在仿真刚开始时，四态数据类型的值是逻辑X。类似有限状态机这样的模型中，四态变量的X逻辑值可以用来表示模型还没有复位，或复位逻辑的建模不正确。 仿真刚开始时，两态数据类型的缺省值是0而不是X。因为复位操作通常是将大部分变量清0，所以这样一来即使复位逻辑有缺陷，模型好像仍然是被复位了。 仿真开始时，枚举类型使用枚举类型的基类值作为缺省值。如果状态变量用默认基类和标签值定义并且复位操作也是将枚举值置为表中的第一个值，那么就会出现和两态变量类似
StateS:绘制和模拟有限状态机（FSM）-开源
04-29
绘制有限状态机（FSM）的简单工具。 支持FSM构建，模拟并导出到VHDL和PDF。 *在Linux下执行StateS需要Qt（Windows版本为独立版本）*开发的早期阶段！ StateS并不是完整的，甚至暂时还没有用！ 但是，欢迎您对其进行测试，并根据您的反馈帮助我进行改进。 但是，请在使用前查阅已知的错误文件。 我使用ArchLinux进行开发。 Windows版本是为了方便起见而提供的，但是通常未经测试，并且可能不是最新版本。 请查阅发行说明或git存储库以了解当前版本。 不再提供32位版本，如果您使用的是32位平台，请从Git存储库中构建软件。
简单FSM 状态机
09-07
简单FSM 状态机,参考网站！ http://www.voidinspace.com/2013/05/a-simple-finite-state-machine-with-c-delegates-in-unity/ http://ai-depot.com/FiniteStateMachines/FSM-Framework.html http://www.richardlord.net/blog/tag/finite-state-machine
剑指 Offer 20. 表示数值的字符串
weixin_45798182的博客
05-27 54
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。 数值（按顺序）可以分成以下几个部分： 若干空格 一个 小数 或者 整数 （可选）一个 'e' 或 'E' ，后面跟着一个 整数 若干空格 小数（按顺序）可以分成以下几个部分： （可选）一个符号字符（'+' 或 '-'） 下述格式之一： 至少一位数字，后面跟着一个点 '.' 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字 一个点 '.' ，后面跟着至少一位数字 整数（按顺序）可以分成以下几个部分： （可...
怎么画一个 有限状态机
qq_46264636的博客
02-22 639
有限状态机对于证明某些问题是可计算的（或不可计算的）是必要的。 由于我目前正在学习有关它们的一些知识，我希望能够自动绘制这些有限自动机。我将使用 。该图像是从 gv 文件创建的。我将其另存为 fsm.gv： 要创建图形（或非确定性有限状态机的图片），您必须在 Ubuntu Linux 中输入以下命令： Deterministic finite-state machine ¶ Installation Oder mit apturl installieren, Link: apt://graphvizDO
一文搞懂有限状态机FSM
weixin_44973391的博客
04-03 2410
1.什么是有限状态机？ 有限状态机（Finite State Machine,FSM),有时候也简称状态机，它是一种数学模型，通常用来设计电脑程序或者时序电路。它被构思为一个抽象的机器，并且在某个时刻只能处于一个有限的数字代表之下。 组成元素：输入、输出、状态、状态转移条件； 描述方式：状态转移图、状态转移表、HDL描述 分类： 按照输出的产生方式，可以将状态机分为两类： Moore:时序逻辑的输...
Verilog学习----有限状态机的设计的一般步骤
weixin_34278190的博客
07-17 301
有限状态机的设计的一般步骤： （1）逻辑抽象，得出状态转换图。 就是把给出的一个实际逻辑关系表示为时序逻辑函数，可以用状态转换表来描述，也可以用状态转换图来描述。这就需要： 1）分析给定的逻辑问题，确定输入变量、输出变量以及电路的状态数。通常是取原因（或条件）作为输入变量，取结果作为输出变量。 2）定义输入、输出逻辑状态的含意，并将电路状态顺序编号。 3）按照要求列出...
简单图解有限状态机与状态模式
代码有点烂
12-03 1万+
限状态机将一个对象的行为分解为容易处理的“块”或者状态，对象执行了某些变换对象将从一个状态变成了另一种状态，说的简单点就是状态流程图，然后这些状态的数量是有限的。 毛星云的博客里举了一个很好的例子说明我们为什么要使用有限状态机。 http://blog.csdn.net/poem_qianmo/article/details/52824776 就拿他举的例子说明吧： 假如我们现在正在开发一...
【产品】产品之术：一目了然的状态机图
小小技术，大大构想
09-21 3099
什么状态机图，它的使用场景是什么？文章为你解读。 一、什么是状态机？ 做产品的时候，我们总能遇到一些比较复杂的逻辑问题。 比如状态的转换，字段状态的确认，权限的控制，状态的对应。 而普通的流程图，或时序图，更侧重于流程和动作的描述，对于对象和状态的解读缺乏直观。 这里我们推荐一种方式，就是画一个简单的状态机图： 那么什么是状态机呢？状态机我们将的一般是指有限状态机： 有限状态机，（英语：Fi...
fsm有限状态机 c
09-10
有限状态机（FSM）是一个数学模型，用于描述具有有限数量状态的系统的行为。FSM有三个主要组成部分：状态集合、输入集合和状态转换函数。 首先，有限状态机由一组离散的状态组成。状态是系统在特定时间点的情况的表示，可以是一个特定的变量或属性。例如，一个交通信号灯可以有三种状态：红灯、黄灯和绿灯。 其次，有限状态机还包括输入集合，可以触发状态之间的转换。输入可以是外部条件，例如一个按钮的按下、一个传感器的数据或一个特定的事件。例如，在交通信号灯的情况下，按下按钮可能是一个输入，将状态从红灯转换到绿灯。 最后，有限状态机还包括状态转换函数，它指示在给定状态和输入情况下系统应该如何转换到下一个状态。转换可以是确定性的，也可以是非确定性的。在交通信号灯的情况下，状态转换函数可以定义为：当状态是红灯时，如果接收到按钮按下的输入，则将状态转换为绿灯。 通过将这三个组成部分结合起来，我们可以使用有限状态机来描述和计算系统的行为。FSM广泛应用于计算机科学和工程领域，用于模型验证、软件开发、自动控制等领域。 总之，有限状态机是一种简单但强大的数学模型，用于描述具有有限数量状态的系统的行为。它通过状态集合、输入集合和状态转换函数来建模系统，用于解决各种计算和控制问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值