添加自动关闭

tangxu

2022-10-27 7e7e1c9dd1c39b2c38b0a758f3cc9faa0921b808

添加自动关闭

 Socket/IStation.DataDockingSocket4NT/MsgHandle/HandleHelper.cs

@@ -11,7 +11,11 @@
{
    public class HandleHelper : IDataDockingSocket.IHandleHelper
    {
   
        static  IMonitorDataDockingSession _session;
        public static IMonitorDataDockingSession GetLastSession()
        {//关机用的是定时器, å®šæ—¶å™¨é‡Œé¢éœ€è¦èŽ·å–最近的一次链接
            return _session;
        }


        /// <summary>
@@ -53,7 +57,7 @@
        /// </summary>
        public void HandleHeartbeat(IMonitorDataDockingSession session)
        {

            _session = session;
        }

        /// <summary>
@@ -75,9 +79,9 @@
            {
                return;
            }

            if (MonitorMsgHelper.IsCurrentMsg(byteMessage))
            {
            _session = session;
            if (MonitorMsgHelper.IsNeedHandle(byteMessage))
            {//监控指令
                var receList = MonitorMsgHelper.HandleReceive(byteMessage);
                if (receList == null || receList.Count == 0)
                    return;
@@ -94,14 +98,16 @@
                return;//成功就返回掉
            }
            //不要加else
            if (ShunDownMsgHelper.InstructionStatus == eShutDownInstructionStatus.关机机指令发送)
            if (ShutDownMsgHelper.IsNeedHandle(byteMessage))
            {
                ShunDownMsgHelper.HandleReceive(session,byteMessage);
                if (ShutDownMsgHelper.HandleReceive(session, byteMessage))
                    return;
            }
            //不要加else
            if (StartUpMsgHelper.IsCurrentMsg(byteMessage))
            if (StartUpMsgHelper.IsNeedHandle(byteMessage))
            {

                if (StartUpMsgHelper.HandleReceive(session, byteMessage))
                    return;
            }

        }

 Socket/IStation.DataDockingSocket4NT/MsgHandle/MonitorMsgHelper.cs

@@ -15,11 +15,11 @@
    internal class MonitorMsgHelper
    {
        /// <summary>
        /// æ˜¯å¦æ˜¯å½“前MSG
        /// æ˜¯å¦æ˜¯å½“前MSG,表示需要处理
        /// </summary>
        /// <param name="byteMessage"></param>
        /// <returns></returns>
        public static bool IsCurrentMsg(byte[] byteMessage)
        public static bool IsNeedHandle(byte[] byteMessage)
        {
            if (byteMessage[0] == 0x01 && byteMessage[1] == 0x03 && byteMessage[2] == 0x42)
            {

 Socket/IStation.DataDockingSocket4NT/MsgHandle/ShunDownMsgHelper.cs

ÎļþÒÑɾ³ý

 Socket/IStation.DataDockingSocket4NT/MsgHandle/ShutDownMsgHelper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,153 @@
using IStation.DataDockingSocket.MsgHandle;
using IStation.Untity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.DataDockingSocket 
{
    internal class ShutDownMsgHelper
    {
        public static eShutDownInstructionStatus  InstructionStatus = eShutDownInstructionStatus.未发送;
        public static DateTime _lastSendTime  ;
        /// <summary>
        /// å¼€å§‹å…³æœº
        /// </summary>
        /// <param name="session"></param>
        /// <returns></returns>
        public static bool StartJob(Model.IMonitorDataDockingSession session)
        {
            if (session != null)
            {
                NtLogHelper.Error($"关机 session:Close");
                return false;
            }

            if (!session.IsConnected)
            {
                NtLogHelper.Error($"关机时 session:Not connected");
                return false;
            }

            byte[] bts = GetControlMsg();

            session.Send(bts, 0, bts.Length);
            InstructionStatus = eShutDownInstructionStatus.关机指令发送;
            _lastSendTime = DateTime.Now;



            NtLogHelper.Debug("关机指令发送:" + session.SessionName + ":" + BitTransfer.ToString(bts)  );

            return true;
        }

        /// <summary>
        /// è‡ªåŠ¨å…³é—­
        /// </summary>
        static System.Timers.Timer _timeAutoClose;
        public static void StartAutoClose(double second)
        {
            NtLogHelper.Info("开启自动关机模式 æ—¶é—´:" + second+"s");
            _timeAutoClose = new System.Timers.Timer(10000 * second);//实例化Timer类，设置间隔时间为10000毫秒；
            _timeAutoClose.Elapsed += new System.Timers.ElapsedEventHandler(ExecuteAutoClose);//到达时间的时候执行事件；
            _timeAutoClose.AutoReset = false;//设置是执行一次（false）还是一直执行(true)；
            _timeAutoClose.Enabled = true;//是否执行System.Timers.Timer.Elapsed事件；
            _timeAutoClose.Start(); //启动定时器
        }
        private static void ExecuteAutoClose(object source, System.Timers.ElapsedEventArgs e)
        {
            if (_timeAutoClose == null)
                return;

            _timeAutoClose.Stop(); //先关闭定时器
            _timeAutoClose = null;
            //要执行的业务代码
            NtLogHelper.Info("正在自动关机...." );
            ShutDownMsgHelper.StartJob(HandleHelper.GetLastSession());

            // t.Start(); //执行完毕后再开启器
        }
        /// <summary>
        /// æ˜¯å¦æ˜¯æŽ§åˆ¶æŒ‡ä»¤
        /// </summary>
        /// <param name="byteMessage"></param>
        /// <returns></returns>
        public static bool IsControlMsg(byte[] byteMessage)
        {  
            return false;
        }

        /// <summary>
        /// å…³æœºæŒ‡ä»¤
        /// </summary>
        static string ControlMsg = "01-06-00-10-00-01-49-CF";

        /// <summary>
        /// èŽ·å–控制指令(关机指令)
        /// </summary>
        /// <returns></returns>
        public static byte[] GetControlMsg()
        {
            // var appParas = AppParasHelper.GetInstance();
            // if (appParas == null || appParas.InstructionStartUp == null || appParas.InstructionStartUp.Content == null)
            {
                return BitTransfer.FromString(ControlMsg);
            }
            //  return BitTransfer.FromString(appParas.InstructionStartUp.Content);
        }

        /// <summary>
        /// æ˜¯å¦éœ€è¦å½“前类进行处理
        /// </summary>
        /// <param name="byteMessage"></param>
        /// <returns></returns>
        public static bool IsNeedHandle(byte[] byteMessage)
        {
            if (InstructionStatus == eShutDownInstructionStatus.关机指令发送)
                return true ;
                       
            return false;
        }
        /// <summary>
        /// è¯»å–返回消息 å¤„理成功返回成功, ä¸æˆåŠŸæˆ–者不需要处理返回false
        /// </summary>
        /// <param name="byteMessage"></param>
        public static bool HandleReceive(Model.IMonitorDataDockingSession session,byte[] byteMessage)
        {
            if (InstructionStatus == eShutDownInstructionStatus.未发送)
                return false ;
            if (InstructionStatus == eShutDownInstructionStatus.关机指令发送)
            {
                if (byteMessage.Length >= ControlMsg.Length)
                {
                    string strMessage = BitConverter.ToString(byteMessage, 0, byteMessage.Length);
                    if (strMessage == ControlMsg)
                    {
                        InstructionStatus = eShutDownInstructionStatus.未发送;

                        NtLogHelper.Debug("关机指令返回:" + BitTransfer.ToString(byteMessage)  );

                        if(_timeAutoClose != null)
                        {
                            _timeAutoClose.Stop(); //先关闭定时器
                            _timeAutoClose = null;
                        }
  
                        return true ;
                    }
                }
                //返回失败, å†å‘送一次再确认一下
                if((DateTime.Now- _lastSendTime).TotalSeconds > 3)
                {
                    StartJob(session);                
                }          
            }

            return false;
        }
       
    }
}

 Socket/IStation.DataDockingSocket4NT/MsgHandle/StartUpMsgHelper.cs

@@ -1,69 +1,150 @@
using IStation.DataDockingSocket.MsgHandle;
using IStation.Model;
using IStation.Untity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Collections.Specialized.BitVector32;

namespace IStation.DataDockingSocket 
{
    internal class StartUpMsgHelper
    {
        public static eStartUpInstructionStatus ShutUpInstructionStatus = eStartUpInstructionStatus.未发送;
        public static eStartUpInstructionStatus InstructionStatus = eStartUpInstructionStatus.未发送;
        public static DateTime _lastHzSendTime;
        public static DateTime _lastOpenSendTime;
        public static MonitorTestControlParas.StartContext _lastParas = null;

        /// <summary>
        /// å¼€æœº
        /// </summary>
        /// <param name="session"></param>
        /// <returns></returns>
        public static bool StartJob(Model.IMonitorDataDockingSession session)
        public static bool StartJob(Model.IMonitorDataDockingSession session, MonitorTestControlParas.StartContext paras)
        {
            if (session != null)
            {
                NtLogHelper.Error($"开机 session:Close");
                return false;
            }

            if (session.IsConnected)
            if(paras == null)
            {
                byte[] bts = GetControlMsg开机();

                session.Send(bts, 0, bts.Length);
                ShutUpInstructionStatus = eStartUpInstructionStatus.调频指令发送;
                NtLogHelper.Info("开机" + session.SessionName + ":" + BitTransfer.ToString(bts) + ", å‘送一条请求控制指令");

                return true;
                NtLogHelper.Error($"开机参数为空");
                return false;
            }
            else

            if (!session.IsConnected)
            {
                NtLogHelper.Error($"开机时 session:Not connected");
                return false;
            }
            if (paras.HZ <= 10)
            {
                NtLogHelper.Error($"开机时 è®¾ç½®çš„调频频率过低!");
                return false;
            }
            _lastParas = paras;

            //switch (context.OperatingMode)
            //{
            //    case Model.MonitorTestControlParas.eOperatingMode.Timing:
            //        break;
            //    case Model.MonitorTestControlParas.eOperatingMode.ConstantFlow:
            //        break;
            //    default:
            //        break;
            //}

            byte[] bts = GetControlMsg调频(paras.HZ);


            session.Send(bts, 0, bts.Length);
            InstructionStatus = eStartUpInstructionStatus.调频指令发送;
            _lastHzSendTime = DateTime.Now;

            NtLogHelper.Info("开机指令: è°ƒé¢‘ " + BitTransfer.ToString(bts) + ", HZ:"+ paras.HZ);

            return true;
        }


        /// <summary>
        /// 
        /// æ˜¯å¦éœ€è¦å½“前类进行处理
        /// </summary>
        /// <param name="byteMessage"></param>
        /// <returns></returns>
        public static bool IsCurrentMsg(byte[] byteMessage)
        public static bool IsNeedHandle(byte[] byteMessage)
        {
            if(byteMessage.Length == 8)
            if(InstructionStatus != eStartUpInstructionStatus.未发送)
                return true;
            else
                return false;
        }
        /// <summary>
        /// å…³æœºæŒ‡ä»¤
        /// </summary>
        static string ControlMsgOpen = "01-06-00-0F-00-01-78-09";
        /// <summary>
        /// è¯»å–返回消息 å¤„理成功返回成功, ä¸æˆåŠŸæˆ–者不需要处理返回false
        /// </summary>
        /// <param name="byteMessage"></param>
        public static bool HandleReceive(Model.IMonitorDataDockingSession session, byte[] byteMessage)
        {
            if (InstructionStatus == eStartUpInstructionStatus.未发送)
                return false;
            if (InstructionStatus == eStartUpInstructionStatus.开机指令发送)
            {
                if (byteMessage[0] == 0x01 && byteMessage[1] == 0x06 && byteMessage[2] == 0x00
    && byteMessage[3] == 0x0F && byteMessage[4] == 0x00 && byteMessage[5] == 0x01
    && byteMessage[6] == 0x78 && byteMessage[7] == 0x09)
                {//01-06-00-0F-00-01-78-09
                    return true;
                if (byteMessage.Length >= ControlMsgOpen.Length)
                {
                    string strMessage = BitConverter.ToString(byteMessage, 0, byteMessage.Length);
                    if (strMessage == ControlMsgOpen)
                    {//01-06-00-0F-00-01-78-09
                        InstructionStatus = eStartUpInstructionStatus.未发送;

                        NtLogHelper.Debug("开机指令返回:" + BitTransfer.ToString(byteMessage));
                        //开启自动关闭
                        ShutDownMsgHelper.StartAutoClose(_lastParas.OperatingValue);
                        return true;
                    }
                }
                //返回失败, å†å‘送一次再确认一下
                if ((DateTime.Now - _lastOpenSendTime).TotalSeconds > 5)
                {
                    SendOpenMsg(session);
                }
            }
      
            if (InstructionStatus == eStartUpInstructionStatus.调频指令发送)
            {
                //需要判断是否是调频指令:以后再补充
                {
                    SendOpenMsg(session);
                }


                //返回失败, å†å‘送一次再确认一下
                if ((DateTime.Now - _lastHzSendTime).TotalSeconds > 5)
                {
                    StartJob(session, _lastParas);
                }
            }

            return false;
        }

        private static  void SendOpenMsg(Model.IMonitorDataDockingSession session)
        {
            byte[] bts = GetControlMsg开机();


            session.Send(bts, 0, bts.Length);
            InstructionStatus = eStartUpInstructionStatus.开机指令发送;
            _lastOpenSendTime = DateTime.Now;

            NtLogHelper.Info("开机指令: å¼€æœº " + BitTransfer.ToString(bts) + ",  ");
        }

 
        /// <summary>
        /// èŽ·å–控制指令(开机)
        /// </summary>
@@ -73,7 +154,7 @@
            //var appParas = AppParasHelper.GetInstance();
            //if (appParas == null || appParas.InstructionStartUp == null || appParas.InstructionStartUp.Content == null)
            {
                return BitTransfer.FromString("01-06-00-0F-00-01-78-09");
                return BitTransfer.FromString(ControlMsgOpen);
            }
            //return BitTransfer.FromString(appParas.InstructionStartUp.Content);
        }

 Socket/IStation.DataDockingSocket4NT/control/SendControlJobHelper.cs

@@ -56,7 +56,7 @@
                        {
                            case Model.MonitorTestControlParas.eControlType.Stop:
                                {
                                    ShunDownMsgHelper.StartJob(session);
                                    ShutDownMsgHelper.StartJob(session);
                                }
                                break;
                            case Model.MonitorTestControlParas.eControlType.Start:
@@ -66,16 +66,8 @@
                                    var context = Model.MonitorTestControlParas.StartContext.ToModel(paras.Context);
                                    if (context == null)
                                        return default;
                                    switch (context.OperatingMode)
                                    {
                                        case Model.MonitorTestControlParas.eOperatingMode.Timing:
                                            break;
                                        case Model.MonitorTestControlParas.eOperatingMode.ConstantFlow:
                                            break;
                                        default:
                                            break;
                                    }
                                    // StartUpMsgHelper.StartJob(session);

                                    StartUpMsgHelper.StartJob(session, context);
                                }
                                break;
                            default:

 Socket/IStation.DataDockingSocket4NT/paras/eShutDownInstructionStatus.cs

@@ -9,7 +9,7 @@
    public enum eShutDownInstructionStatus
    {
        æœªå‘送 = 0, 
        å…³æœºæœºæŒ‡ä»¤å‘送 = 3,
        å…³æœºæŒ‡ä»¤å‘送 = 3,
        //关机指令返回 = 4
    }
}

 Socket/IStation.DataDockingSocket4NT/paras/eStartUpInstructionStatus.cs

@@ -9,9 +9,7 @@
    public enum eStartUpInstructionStatus
    {
        æœªå‘送 = 0,
        è°ƒé¢‘指令发送 = 1,
        è°ƒé¢‘指令返回 = 2,
        å¼€æœºæŒ‡ä»¤å‘送 = 3,
        å¼€æœºæŒ‡ä»¤è¿”回 = 4
        è°ƒé¢‘指令发送 = 1, 
        å¼€æœºæŒ‡ä»¤å‘送 = 3, 
    }
}

 Untity/IStation.Untity/ת»»/BitTransfer.cs

@@ -26,14 +26,47 @@
        {
            try
            {
                string[] strSplit = str.Split(spliter);
                return strSplit.Select(x => byte.Parse(x, System.Globalization.NumberStyles.AllowHexSpecifier)).ToArray();
               
                    string[] strSplit = str.Split(spliter);
                    return strSplit.Select(x => byte.Parse(x, System.Globalization.NumberStyles.AllowHexSpecifier)).ToArray();
      
            }
            catch
            {
                return default;
            }
        }
        /// <summary>
        /// å­—符串转16进制字符2
        /// </summary>
        /// <param name="content">字符串</param>
        /// <param name="encode">编码格式</param>
        /// <returns></returns>
        private List<byte> FromString(string content, out string error_info)
        {
            //去掉空格
            string[] arr = content.Split(' ');
            if (arr.Length < 3)
            {
                arr = content.Split('-');
                if (arr.Length < 3)
                {
                    error_info = "字符无法解析";
                    return null;
                }
            }
            List<byte> result = new List<byte>();
            for (int i = 0; i < arr.Length; i++)
            {
                if (string.IsNullOrWhiteSpace(arr[i]))
                    continue;

                var dddd = Convert.ToByte(arr[i], 16);
                result.Add(dddd);
            }
            error_info = null;
            return result;
        }


    }