工业状态控制

 

namespace 工业状态机
{
    public partial class MainForm : Form
    {
        private StateMachine stateMachine; 

        public MainForm()
        {
            InitializeComponent();
        }

        private void MainForm_Load(object sender, EventArgs e)
        {
            stateMachine = new StateMachine();
            stateMachine.OnLogMessage += OnLogMessage;
            stateMachine.OnStateChanged += OnStateChanged;

            UpdateUI();
        }

        private void OnLogMessage(string message)
        {
            rtbMsg.AppendText(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " " + message + "\n");
        }

        private void OnStateChanged(设备状态 oldState, 设备状态 newState)
        {
            UpdateUI(); 
        }

        private void UpdateUI()
        {
            // 更新状态指示器 
            foreach (Control control in groupBoxStateIndicators.Controls) { if (control is Label label) label.BackColor = Color.LightGray; }
            var currentIndicator = groupBoxStateIndicators.Controls.OfType<Label>().FirstOrDefault(l => l.Tag?.ToString() == stateMachine.CurrentState.ToString());
            if (currentIndicator != null) currentIndicator.BackColor = Color.White;

            // 更新可用状态
            var allowedEvents = stateMachine.GetAllowedEvents();
            btnInitialize.Enabled = allowedEvents.Contains(设备事件.初始化);
            btnStart.Enabled = allowedEvents.Contains(设备事件.启动);
            btnPause.Enabled = allowedEvents.Contains(设备事件.暂停);
            btnResume.Enabled = allowedEvents.Contains(设备事件.恢复);
            btnStop.Enabled = allowedEvents.Contains(设备事件.停止);
            btnReset.Enabled = allowedEvents.Contains(设备事件.重置);
            btnMaintenance.Enabled = allowedEvents.Contains(设备事件.维护);
            btnError.Enabled = allowedEvents.Contains(设备事件.错误);
            BtnComplete.Enabled = allowedEvents.Contains(设备事件.完成);
        }

        private void BtnInitialize_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.初始化);
        private void BtnStart_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.启动);
        private void BtnPause_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.暂停);
        private void BtnResume_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.恢复);
        private void BtnStop_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.停止);
        private void BtnReset_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.重置);
        private void BtnMaintenance_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.维护);
        private void BtnError_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.错误);
        private void BtnComplete_Click(object sender, EventArgs e) => stateMachine.TriggerEvent(设备事件.完成);

        private void BtnClear_Click(object sender, EventArgs e)
        {
            rtbMsg.Clear();
        }
    }
}

public enum 设备状态
{
    空闲,
    初始化,
    准备就绪,
    运行中,
    暂停,
    停止中,
    错误,
    维护
}

public enum 设备事件
{
    初始化,
    启动,
    暂停,
    恢复,
    停止,
    重置,
    错误,
    维护,
    完成
}

/// <summary>
/// 状态机核心类
/// </summary>
public class StateMachine
{
    设备状态 currentState = 设备状态.空闲;
    Dictionary<(设备状态, 设备事件), 设备状态> stateTransitions;

    public 设备状态 CurrentState
    {
        get => currentState;
        private set
        {
            var oldState = currentState;
            currentState = value;
            OnStateChanged?.Invoke(oldState, currentState);
        }
    }

    public event Action<设备状态, 设备状态> OnStateChanged;
    public event Action<string> OnLogMessage;

    public StateMachine()
    {
        InitializeStateTransitions();
    }

    /// <summary>
    /// 初始化状态转换表
    /// </summary>
    private void InitializeStateTransitions()
    {
        stateTransitions = new Dictionary<(设备状态, 设备事件), 设备状态>
        { 
            // 设备空闲时，只能进行初始化或维护
            { (设备状态.空闲, 设备事件.初始化), 设备状态.初始化 },
            { (设备状态.空闲, 设备事件.维护), 设备状态.维护 },

            { (设备状态.初始化, 设备事件.完成), 设备状态.准备就绪 },
            { (设备状态.初始化, 设备事件.错误), 设备状态.错误 },

            { (设备状态.准备就绪, 设备事件.启动), 设备状态.运行中 },
            { (设备状态.准备就绪, 设备事件.维护), 设备状态.维护 },
            { (设备状态.准备就绪, 设备事件.错误), 设备状态.错误 },

            { (设备状态.运行中, 设备事件.暂停), 设备状态.暂停 },
            { (设备状态.运行中, 设备事件.停止), 设备状态.停止中 },
            { (设备状态.运行中, 设备事件.错误), 设备状态.错误 },

            { (设备状态.暂停, 设备事件.恢复), 设备状态.运行中 },
            { (设备状态.暂停, 设备事件.停止), 设备状态.停止中 },
            { (设备状态.暂停, 设备事件.错误), 设备状态.错误 },

            { (设备状态.停止中, 设备事件.完成), 设备状态.空闲 },
            { (设备状态.停止中, 设备事件.错误), 设备状态.错误 },

            { (设备状态.错误, 设备事件.重置), 设备状态.空闲 },
            { (设备状态.错误, 设备事件.维护), 设备状态.维护 },

            { (设备状态.维护, 设备事件.完成), 设备状态.空闲 }
        };
    }

    /// <summary>
    /// 触发状态转换事件
    /// </summary>
    public bool TriggerEvent(设备事件 stateEvent)
    {
        if (stateTransitions.TryGetValue((CurrentState, stateEvent), out 设备状态 newState))
        {
            var message = $"状态转换: {GetStateDisplayName(CurrentState)} → {GetStateDisplayName(newState)} (事件: {GetEventDisplayName(stateEvent)})";
            OnLogMessage?.Invoke(message);
            CurrentState = newState;
            return true;
        }
        else
        {
            var message = $"无效的状态转换: 在状态 {GetStateDisplayName(CurrentState)} 下无法处理事件 {GetEventDisplayName(stateEvent)}";
            OnLogMessage?.Invoke(message);
            return false;
        }
    }

    /// <summary>
    /// 获取当前状态允许的事件
    /// </summary>
    public List<设备事件> GetAllowedEvents()
    {
        var allowedEvents = new List<设备事件>();
        foreach (var transition in stateTransitions.Keys)
        {
            if (transition.Item1 == CurrentState)
            {
                allowedEvents.Add(transition.Item2);
            }
        }
        return allowedEvents;
    }

    /// <summary>
    /// 获取状态显示名称
    /// </summary>
    static string GetStateDisplayName(设备状态 state)
    {
        return state switch
        {
            设备状态.空闲 => "空闲",
            设备状态.初始化 => "初始化中",
            设备状态.准备就绪 => "准备就绪",
            设备状态.运行中 => "运行中",
            设备状态.暂停 => "已暂停",
            设备状态.停止中 => "停止中",
            设备状态.错误 => "错误",
            设备状态.维护 => "维护中",
            _ => state.ToString()
        };
    }

    /// <summary>
    /// 获取事件显示名称
    /// </summary>
    static string GetEventDisplayName(设备事件 stateEvent)
    {
        return stateEvent switch
        {
            设备事件.初始化 => "初始化",
            设备事件.启动 => "启动",
            设备事件.暂停 => "暂停",
            设备事件.恢复 => "恢复",
            设备事件.停止 => "停止",
            设备事件.重置 => "重置",
            设备事件.错误 => "错误",
            设备事件.维护 => "维护",
            设备事件.完成 => "完成",
            _ => stateEvent.ToString()
        };
    }
}