设备控制(反馈处理)

因为项目的关系，经常需要程序控制各种设备并接收设备消息反馈，这里以中控为例，说下我对消息反馈的做法。

首先需要根据具体的消息反馈建立对应的类，分别为总电源，大屏模式，灯光。

    public enum Power { Off, On }

    public class PowerNotify : Notify {
        public Power Power { get; set; }
    }

    public class ApolloModeNotify : Notify {
        public int Mode { get; set; }
    }

    public class LightNotify : Notify {
        public int Id { get; set; }
        public Power Power { get; set; }
    }

因为通过网络接收到的消息反馈是字符串类型的，所以需要一个用于转换的类，将不同的字符串转换成对应的反馈对象。

    public delegate void NotifyEventHandler(Notify notify);

    public class CrestronHandler {
        public event NotifyEventHandler OnNotifyReceived;

        public CrestronHandler(Client client) {
            InstallHandler();

            this.client = client;
            client.OnDataReceived += new DataReceivedEventHandler(OnDataReceived);
        }

        private Client client;
    }

这里的Client是Tcp连接客户端，接收反馈字符串。

InstallHandler用于记录转换关系：

        public delegate bool IsMsgFit(string msg);
        public delegate List<Notify> NotifyGenerateHandler(string msg);

        private void InstallHandler() {
            condition2Handler.Add(IsPowerMsg, GenPowerNotify);
            condition2Handler.Add(IsApolloMsg, GenApolloNotify);
            condition2Handler.Add(IsLightMsg, GenLightNotify);
        }
        private Dictionary<IsMsgFit, NotifyGenerateHandler> condition2Handler = new Dictionary<IsMsgFit, NotifyGenerateHandler>();

具体的转换如下：

        private bool IsPowerMsg(string msg) {
            return msg.StartsWith("POWERFB");
        }

        private bool IsApolloMsg(string msg) {
            return msg.StartsWith("APOLLOFB");
        }

        private bool IsLightMsg(string msg) {
            return msg.StartsWith("LIGHT");
        }

        private List<Notify> GenPowerNotify(string msg) {
            Notify notify = null;
            if (msg.Contains("ALLON")) {
                notify = new PowerNotify { Power = Power.On };
            } else if (msg.Contains("ALLOFF")) {
                notify = new PowerNotify { Power = Power.Off };
            }

            return new List<Notify> { notify };
        }

        private List<Notify> GenApolloNotify(string msg) {
            Notify notify = null;
            if (msg.Contains("MODE")) {
                int mode = Convert.ToInt32(msg.Substring(13));
                notify = new ApolloModeNotify { Mode = mode };
            }

            return new List<Notify> { notify };
        }

        private List<Notify> GenLightNotify(string msg) {
            string[] subMsg = msg.Split(new string[] { "LIGHT", "FB:" }, StringSplitOptions.RemoveEmptyEntries);
            int id = Convert.ToInt32(subMsg[0]);
            Power power = (subMsg[1] == "ON") ? Power.On : Power.Off;
            LightNotify notify = new LightNotify { Id = id, Power = power };
            return new List<Notify> { notify };
        }

然后就是接收反馈字符串，逐一进行尝试是否符合条件，符合的话就生成对应的反馈对象，

并触发OnNotifyReceived事件，程序中关心反馈的地方只要订阅此事件并做相应的反馈处理即可。

        private void OnDataReceived(byte[] data) {
            string msg = Encoding.ASCII.GetString(data).ToUpper();

            foreach (var each in condition2Handler) {
                if (each.Key(msg)) {
                    List<Notify> notifys = null;
                    try {
                        notifys = each.Value(msg);
                        if (notifys == null) { throw new Exception(); }
                    } catch {
                        Logger.Instance.Warn(string.Format("接收到无法解析的命令 => 【{0}】", msg));
                        return;
                    }

                    try {
                        foreach (var notify in notifys) {
                            if (OnNotifyReceived != null) OnNotifyReceived(notify);
                        }
                    } catch (Exception ex) {
                        Logger.Instance.WarnWithException(this, "client_NotifyHandler", "Notify执行失败", ex);
                    }

                    break;
                }
            }
        }