【与GPT对话】状态机（持续更新）哈士奇算法

三少爷的甲壳虫

已于 2023-08-29 13:56:09 修改

阅读量344

点赞数 1

文章标签： ui python 开发语言

于 2023-03-21 11:09:45 首次发布

本文链接：https://blog.csdn.net/sinat_36912383/article/details/129684129

版权

状态机

什么工具可以检查状态机的问题
状态机存在哪些问题
用python写一个c语言状态机生成器

什么工具可以检查状态机的问题

有许多工具可以检查状态机的问题，其中一些工具如下：

State-Pro实验室：这是一种企业级状态机测试工具，具有设计可行性分析，自动测试和基于模型的测试等功能。
Uppaal：这是一种针对系统和协议验证的模型检查和模拟工具。它可以在系统模型和运行时属性上进行形式化验证。
Spin：这是一种高效的软件验证工具，它可以用于验证状态机，Petri网和进程。
TAPAAL：这是一种用户友好的工具，用于建模，仿真和验证时间自动机。
Prism：这是一款基于概率模型检查的工具，可以用于验证状态机，马尔可夫决策过程和连续时间马尔可夫链等模型。
Verisoft XT：这是一款通用的模型检查器，它可以用于验证有限状态机，实时系统和安全协议等模型。
以上这些工具都有其优缺点，具体选择哪一种还要根据具体需求和使用环境来进行综合考虑。

状态机存在哪些问题

状态机的设计存在以下几个问题：

状态之间的转换：确定状态之间的转换条件及执行操作，并保证状态之间的转换正确无误。
状态的数量：合理的状态数量是设计状态机时需要考虑的问题，如果状态数量太少，可能会导致状态不完备，无法完成所有的任务；如果状态数量过多，可能会导致状态转换复杂、难以维护。
状态的设计：状态应该根据实际需求进行设计，需要考虑到不同状态的特性和限制，以及状态的并发执行情况。
状态机的实现：状态机的实现方式可以是面向对象的，也可以是基于事件的等等，需要选择适合现有需求的实现方式。

设计状态机时需要注意以下几点：

确定状态：确定需要哪些状态、状态之间的关系及状态的执行顺序。
明确触发条件：明确每个状态转换的触发条件及转换后的状态。
注意并发执行：考虑状态之间的并发执行情况，并做好合理的设计。
实现细节：注意实现细节，比如状态机的初始化、状态执行时机等等。
测试状态机：测试状态机是否符合要求，能够完成预期的任务，并且是否满足性能需求等等。

用python写一个c语言状态机生成器

with termnel UI

在这里插入图片描述

'''
Sure! Here's an updated version of the code that includes a simple UI based on the command line. This UI allows the user to add states and transitions to the state machine, and generates C code based on the current state of the machine.
'''
class State:
    def __init__(self, name, actions):
        self.name = name
        self.actions = actions

class Transition:
    def __init__(self, source, target, condition):
        self.source = source
        self.target = target
        self.condition = condition

class StateMachine:
    def __init__(self):
        self.states = []
        self.transitions = []

    def add_state(self):
        name = input("Enter state name: ")
        actions = input("Enter actions (comma-separated): ")
        actions = [a.strip() for a in actions.split(",")]
        state = State(name, actions)
        self.states.append(state)

    def add_transition(self):
        source = input("Enter source state name: ")
        target = input("Enter target state name: ")
        condition = input("Enter transition condition: ")
        transition = Transition(source, target, condition)
        self.transitions.append(transition)

    def generate_c(self):
        # generate C code for the state machine
        code = "/* Generated by state machine code generator */\n\n"
        code += "enum {\n"
        for i, state in enumerate(self.states):
            code += f"    {state.name} = {i},\n"
        code += "};\n\n"
        code += "void run_state_machine() {\n"
        code += "    int current_state = 0;\n"
        code += "    while (1) {\n"
        code += "        switch (current_state) {\n"
        for state in self.states:
            code += f"            case {state.name}:\n"
            for action in state.actions:
                code += f"                {action};\n"
            code += "                break;\n"
        code += "        }\n"
        code += "        switch (input) {\n"
        for i, transition in enumerate(self.transitions):
            code += f"            case {transition.condition}:"
            code += f"                current_state = {transition.target};\n"
            code += "                break;\n"
        code += "        }\n"
        code += "    }\n"
        code += "}\n"
        return code

# Simple command line UI
def main():
    sm = StateMachine()
    while True:
        print("State machine generator")
        print("1. Add state")
        print("2. Add transition")
        print("3. Generate C code")
        print("4. Quit")
        choice = input("Enter choice: ")
        if choice == "1":
            sm.add_state()
        elif choice == "2":
            sm.add_transition()
        elif choice == "3":
            code = sm.generate_c()
            print("Generated C code:")
            print(code)
        elif choice == "4":
            break
        else:
            print("Invalid choice")

if __name__ == "__main__":
    main()


'''
This code includes a StateMachine class that allows the user to add states and transitions to the state machine. It also includes a generate_c method that generates C code for the state machine based on the current state of the machine.

The main function implements a simple command line UI that prompts the user for input and calls the appropriate methods on the StateMachine object. When the user chooses to generate C code, the code is printed to the console.

Again, you'll need to customize this code to fit your specific UI
'''

代码里直接改

在这里插入图片描述

'''
Writing a C state machine code generator in Python can be a complex task, but it's definitely doable with the right approach. Here's one way you could go about it:

Define a data structure to represent a state machine. This structure should include information about the states, transitions between them, and any actions associated with those transitions.

Write code to parse a user's input into this data structure. This will likely involve some kind of UI where the user can define the states, transitions, and actions. You may want to use a modular approach here to allow the user to add, edit, or remove parts of the state machine as needed.

Write code to generate C code based on the data structure. This will likely involve traversing the state machine and generating C code for each state, transition, and action. You may want to use a templating engine or other code generation tools to make this process easier.

Here's a rough outline of what the code might look like:
'''
class State:
    def __init__(self, name, actions):
        self.name = name
        self.actions = actions

class Transition:
    def __init__(self, source, target, condition):
        self.source = source
        self.target = target
        self.condition = condition

class StateMachine:
    def __init__(self, states, transitions):
        self.states = states
        self.transitions = transitions

    def generate_c(self):
        # generate C code for the state machine
        code = "/* Generated by state machine code generator */\n\n"
        code += "enum {\n"
        for state in self.states:
            code += f"    {state.name},\n"
        code += "};\n\n"
        code += "void run_state_machine() {\n"
        code += "    int current_state = 0;\n"
        code += "    while (1) {\n"
        code += "        switch (current_state) {\n"
        for state in self.states:
            code += f"            case {state.name}:\n"
            for action in state.actions:
                code += f"                {action};\n"
            code += "                break;\n"
        code += "        }\n"
        code += "        switch (input) {\n"
        for transition in self.transitions:
            code += f"            case {transition.condition}:"
            code += f"                current_state = {transition.target};\n"
            code += "                break;\n"
        code += "        }\n"
        code += "    }\n"
        code += "}\n"
        return code

# Example usage
states = [
    State("Depy", ["printf('Depy');"]),
    State("Whd", ["printf('Whd');"]),
    State("D2Depy", ["printf('D2Depy');"]),
    State("D2Whd", ["printf('D2Whd');"])
]
transitions = [
    Transition("Depy", "Whd", "(D2Wtimer<=0)&&(arm==Whd)"),
    Transition("Whd", "Depy", "(D2Dtimer<=0)&&(arm==Depy)"),
    Transition("Depy", "D2Whd", "(D2Wtimer>0)&&(arm==Whd)"),
    Transition("Whd", "D2Depy", "(D2Dtimer>0)&&(arm==Depy)"),
    Transition("D2Whd", "Whd", "prvD2Wtimer==0"),
    Transition("D2Depy", "Depy", "prvD2Dtimer==0")
]
sm = StateMachine(states, transitions)
print(sm.generate_c())


'''
This code defines a StateMachine class that contains State and Transition objects. It also includes a generate_c method that generates C code for the state machine based on the data structure. The example usage at the end demonstrates how to create a simple state machine and generate C code for it. Of course, you'll need to adapt this code to your specific use case and UI requirements, but hopefully it gives you a starting point.
'''

生成一个状态机图片

'''
要根据FSM生成UML状态转移图，可以使用Python的Graphviz库和PyDotPlus库。 
下面是一个示例代码，它定义了一个简单的FSM和它的状态转移图。
管理员打开ps：choco install graphviz or winget install graphviz can fix graph.write_png('fsm.png')报错 GraphViz's executables not found

'''
from graphviz import Digraph
import pydotplus
from IPython.display import Image
# 定义FSM状态列表
states = ['A', 'B', 'C', 'D']
# 定义FSM转移列表
transitions = [('A', 'B', '1'), ('B', 'C', '0'),
               ('C', 'D', '1'), ('D', 'A', '0')]
# 初始化一个有向图
graph = Digraph('FSM', filename='fsm.gv')
# 添加状态
for state in states:
    if state == 'A':
        graph.node(state, shape='doublecircle')
    else:
        graph.node(state, shape='circle')
# 添加转移
for transition in transitions:
    graph.edge(transition[0], transition[1], label=transition[2])
# 使用pydotplus库生成图像
dot_data = graph.source
graph = pydotplus.graph_from_dot_data(dot_data)
# 保存图像并显示它
graph.write_png('fsm.png')
Image('fsm.png')

在这里插入图片描述

生成一个tool UI

'''
为了生成一个UI，我们可以使用Python中的Tkinter库。以下是一个展示如何实现上述UI的示例代码：

'''
import tkinter as tk
import fsm3 as fsm


class UI:
    def __init__(self, master):
        self.master = master
        master.title("UI Demo")

        # 创建顶层框架
        self.topframe = tk.Frame(self.master, bd=5, relief="raised")
        self.topframe.pack(side="top", fill="both", expand=True)

        # 创建左侧框架
        self.leftframe = tk.Frame(self.topframe, bd=2, relief="groove")
        self.leftframe.pack(side="left", fill="both", expand=True)

        # 创建右侧框架
        self.rightframe = tk.Frame(self.topframe, bd=2, relief="groove")
        self.rightframe.pack(side="right", fill="both", expand=True)

        # 创建文本框
        self.textbox = tk.Text(self.rightframe, height=10, width=50)
        self.textbox.pack(fill="both", expand=True)

        # 创建输入框
        self.input1 = tk.Entry(self.leftframe)
        self.input1.pack(side="top", padx=5, pady=5, fill="x")
        self.input2 = tk.Entry(self.leftframe)
        self.input2.pack(side="top", padx=5, pady=5, fill="x")

        # 创建按钮
        self.button = tk.Button(self.master, text="生成", command=self.generate)
        self.button.pack(side="bottom", pady=5)

        # 将所有元素设定为居中
        self.center()

    def center(self):
        # 获取屏幕尺寸和当前窗口尺寸
        screen_width = self.master.winfo_screenwidth()
        screen_height = self.master.winfo_screenheight()
        window_width = self.master.winfo_width()
        window_height = self.master.winfo_height()

        # 计算窗口在屏幕上的位置
        x = int((screen_width - window_width)/2)
        y = int((screen_height - window_height)/2)

        # 设置窗口在屏幕上的位置
        self.master.geometry(
            "{}x{}+{}+{}".format(window_width, window_height, x, y))

    def generate(self):
        # 获取输入框内的数组
        input1 = self.input1.get()
        input2 = self.input2.get()

        # 将字符串转化为数组
        arr1 = input1.split(",")
        arr2 = input2.split(",")

        # 将数组转化为整数
        arr1 = list(map(int, arr1))
        arr2 = list(map(int, arr2))

        # 将数组相加
        result = [x + y for x, y in zip(arr1, arr2)]

        # 将结果输出到文本框中
        self.textbox.delete(1.0, tk.END)
        self.textbox.insert(tk.END, str(result))
        self.textbox.insert(tk.END, str(sm.generate_c()))


states = [
    fsm.State("SEC_STATUS_OPENED", ["printf('SEC_STATUS_OPENED');"]),
    fsm.State("SEC_STATUS_CLOSE", ["printf('SEC_STATUS_CLOSE');"]),
    fsm.State("SEC_STATUS_ENTDLY", ["printf('SEC_STATUS_ENTDLY');"]),
    fsm.State("SEC_STATUS_EXITDLY", ["printf('SEC_STATUS_EXITDLY');"])
]
transitions = [
    fsm.Transition("SEC_STATUS_OPENED", "SEC_STATUS_CLOSE",
                   "(D2Wtimer<=0)&&(arm==SEC_STATUS_CLOSE)"),
    fsm.Transition("SEC_STATUS_CLOSE", "SEC_STATUS_OPENED",
                   "(D2Dtimer<=0)&&(arm==SEC_STATUS_OPENED)"),
    fsm.Transition("SEC_STATUS_OPENED", "SEC_STATUS_EXITDLY",
                   "(D2Wtimer>0)&&(arm==SEC_STATUS_CLOSE)"),
    fsm.Transition("SEC_STATUS_CLOSE", "SEC_STATUS_ENTDLY",
                   "(D2Dtimer>0)&&(arm==SEC_STATUS_OPENED)"),
    fsm.Transition("SEC_STATUS_EXITDLY", "SEC_STATUS_CLOSE", "prvD2Wtimer==0"),
    fsm.Transition("SEC_STATUS_ENTDLY", "SEC_STATUS_OPENED", "prvD2Dtimer==0")
]
sm = fsm.StateMachine(states, transitions)


root = tk.Tk()
ui = UI(root)
root.mainloop()
'''
在该代码中，我们首先创建一个UI类，
该类包含了UI中所有的元素和方法。
我们使用Frame小部件来容纳其他小部件。
在我们的UI中，有三个主要的Frame，即顶部Frame，左侧Frame和右侧Frame。
左侧Frame中包含两个输入框，右侧Frame中包含一个文本框。
我们还在底部添加了一个生成按钮。
最后，我们使用center()方法将所有的窗口元素居中。
'''

在这里插入图片描述

python鼠标自动移动器

import pyautogui
import keyboard,sys

# 定义用于切换鼠标移动器的热键
# Set up the hotkeys
start_hotkey = 's'
stop_key = 't'
# 定义用于随机移动鼠标的函数
def main():
    keyboard.wait(start_hotkey)
    while True:
        pyautogui.moveRel(
            pyautogui.moveTo(100, 200, 2),
            pyautogui.moveTo(200, 100, 2)
        )
        if keyboard.is_pressed(stop_key):
            try:
                sys.exit(3)
            except SystemExit as e:
                print(f'进程退出，退出码是{e.code}')

# Call the main function
if __name__ == "__main__":
    main()

哈士奇算法：对于N维矩阵降维为1维序列的简单算法，对数据的的逐个数累加编码

$N\mathop{{}}\nolimits_{1} = \left [ evtA\mathop{{}}\nolimits_{0} , \cdots,evtA\mathop{{}}\nolimits_{max} \right )\\ N\mathop{{}}\nolimits_{2} = \left [ evtB\mathop{{}}\nolimits_{0} ,evtB\mathop{{}}\nolimits_{1}, \cdots,evtB\mathop{{}}\nolimits_{max} \right )\\\vdots\\ N\mathop{{}}\nolimits_{n} = \left [ evtN\mathop{{}}\nolimits_{0} ,evtN\mathop{{}}\nolimits_{1},evtN\mathop{{}}\nolimits_{2}, \cdots,evtN\mathop{{}}\nolimits_{max} \right )\\ \operatorname{Hasky}\left(N_{1}, N_{2}, \cdots, N_{n}\right) = \sum_{i = 1}^{n} N_{i} \cdot \prod_{j = 1}^{i-1} \max \left(N_{j}\right)$