chutian_terminal/communication/channel_communication.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using chutian_parking_terminal.communication_base;
using chutian_parking_terminal.data_buffer;
using tool;
using chutian_parking_terminal.front_terminal_manager;
using System.Windows.Forms;
using System.Threading;
using Google.Protobuf;

namespace chutian_parking_terminal.communication
{
    class Channel_communication : Communication_socket_base
    {
        //由于C#不能多继承 就只能直接写成单例模式了
        /// <summary>
        /// 单例
        /// </summary>
        class Nested
        {
            // 创建模板类实例，参数2设为true表示支持私有构造函数
            internal static readonly Channel_communication instance = Activator.CreateInstance(typeof(Channel_communication), true) as Channel_communication;
        }
        private static Channel_communication instance = null;
        public static Channel_communication Instance
        {
            get
            {
                return Nested.instance;
            }
        }
        int terminalId;
        //定义委托
        public delegate void StoreResponseMsgDelegate(Message.Store_command_response_msg t_store_command_response_msg);
        public delegate void PickupResponseMsgDelegate(Message.Pickup_command_response_msg t_pickup_command_response_msg);
        public delegate void ParkspaceSearchMsgDelegate(Message.Parkspace_search_response_msg t_parkspace_search_response_msg);
        //委托回调句柄
        private StoreResponseMsgDelegate m_SetStoreResponseMsgCallBack;
        private PickupResponseMsgDelegate m_SetPickupResponseMsgCallBack;
        private ParkspaceSearchMsgDelegate m_SetParkspaceSearchMsgCallBack;

        //设置回调函数
        public void SetStoreResponseMsgDelegate(StoreResponseMsgDelegate callback)
        {
            m_SetStoreResponseMsgCallBack = callback;
        }
        public void SetPickupResponseMsgDelegate(PickupResponseMsgDelegate callback)
        {
            m_SetPickupResponseMsgCallBack = callback;
        }
        public void SetParkspaceSearchMsgDelegate(ParkspaceSearchMsgDelegate callback)
        {
            m_SetParkspaceSearchMsgCallBack = callback;
        }

        private Channel_communication()
        {
        }
        public void channel_communication_init()
        {
            terminalId = int.Parse(json_file_operation.Instance.read_json_string("ternimalNumber"));
            base.communication_init();

            m_master_control_connect_status = false;
            m_radar_connect_status = false;
            m_database_connect_status = false;
            m_UnNormalized_module_connect_status = false;

            m_event_exit = new EventWaitHandle(false, EventResetMode.ManualReset);

            mp_check_connect_thread = new Thread(check_connect_thread);
            m_check_connect_condition = true;
            mp_check_connect_thread.Start();
        }
        public void channel_communication_uninit()
        {
            m_master_control_connect_status = false;
            m_radar_connect_status = false;
            m_database_connect_status = false;
            m_UnNormalized_module_connect_status = false;
            m_check_connect_condition = false;
            mp_check_connect_thread.Abort();
            base.communication_uninit();
        }
        private void check_connect_thread()
        {
            while (m_check_connect_condition && !m_event_exit.WaitOne(1))
            {
                if (m_check_connect_condition)
                {
                    if ((DateTime.Now.Ticks / 10000 - m_master_control_recv_time.Ticks / 10000) < 3000)
                    {
                        m_master_control_connect_status = true;
                    }
                    else
                    {
                        m_master_control_connect_status = false;
                    }
                    if ((DateTime.Now.Ticks / 10000 - m_radar_recv_time.Ticks / 10000) < 3000)
                    {
                        m_radar_connect_status = true;
                    }
                    else
                    {
                        m_radar_connect_status = false;

                    }
                    if ((DateTime.Now.Ticks / 10000 - m_database_recv_time.Ticks / 10000) < 3000)
                    {
                        m_database_connect_status = true;
                    }
                    else
                    {
                        m_database_connect_status = false;

                    }
                    if ((DateTime.Now.Ticks / 10000 - m_UnNormalized_module_recv_time.Ticks / 10000) < 3000)
                    {
                        m_UnNormalized_module_connect_status = true;
                    }
                    else
                    {
                        m_UnNormalized_module_connect_status = false;

                    }
                }
            }
        }
        /// <summary>
        /// 检查各个节点连接状态
        /// </summary>
        /// <returns></returns>
        public Message.Error_manager check_statu()
        {
            Message.Error_manager error = new Message.Error_manager();
            if (m_master_control_connect_status &&
                m_radar_connect_status &&
                m_database_connect_status &&
                m_UnNormalized_module_connect_status)
            {
                error.ErrorCode = 0;
                error.ErrorLevel = 0;
                return error;
            }
            else
            {
                error.ErrorCode = 1;
                error.ErrorLevel = Message.Error_level.MinorError;
                if (!m_master_control_connect_status)
                {
                    error.ErrorDescription = error.ErrorDescription+"主控未连接！";
                }
                if (!m_radar_connect_status)
                {
                    error.ErrorDescription = error.ErrorDescription + "雷达未连接！";
                }
                if (!m_database_connect_status)
                {
                    error.ErrorDescription = error.ErrorDescription + "数据库未连接！";
                }
                if (!m_UnNormalized_module_connect_status)
                {
                    error.ErrorDescription = error.ErrorDescription + "非标未连接！";
                }
                else
                {
                    Message.Error_manager unnormalized_module_error_Manager = Front_terminal_manager.Instance.get_unnormalized_module_data_bufferr().get_unnormalized_module_status_msg().StatuCode;
                    if (unnormalized_module_error_Manager.ErrorCode != 0)
                    {
                        error.ErrorDescription = error.ErrorDescription + unnormalized_module_error_Manager.ErrorDescription;
                    }
                }
                return error;
            }

        }
        //重载检查消息--检查是否给终端的消息
        public override bool check_msg(byte[] msg)
        {
            return true;
            //Message.Base_info base_Info = Message.Base_msg.Parser.ParseFrom(msg).BaseInfo;
            //if (base_Info.Receiver == Message.Communicator.ETerminor ||
            //    base_Info.Receiver == Message.Communicator.EEmpty||
            //    base_Info.Receiver == Message.Communicator.EMain)//消息类型为空一般表示状态消息
            //{
            //    return true;
            //}
            //else
            //{
            //    //无效的消息
            //    return false;
            //}
        }
        //重载检查执行者状态
        public override bool check_executer(byte[] msg)
        {
            return true;
        }
        //重载处理消息
        public override void execute_msg(byte[] msg)
        {

            Message.Message_type type = Message.Base_msg.Parser.ParseFrom(msg).BaseInfo.MsgType;
            switch (type)
            {
             
                //终端状态消息
                case Message.Message_type.ETerminalStatusMsg:
                {
                    Message.Terminal_status_msg t_terminal_status_msg = Message.Terminal_status_msg.Parser.ParseFrom(msg);
                        //Console.WriteLine("接收的***:" + t_terminal_status_msg.ToString() + "    " + t_terminal_status_msg.SinglechipValidity.ToString() + "      " + DateTime.Now.Millisecond);
                }
                break;
                //停车请求回馈消息
                case Message.Message_type.EStoreCommandResponseMsg:
                {
                    Message.Store_command_response_msg t_store_command_response_msg = Message.Store_command_response_msg.Parser.ParseFrom(msg);
                    if (t_store_command_response_msg?.IdStruct.TerminalId == terminalId)
                    {
                        m_SetStoreResponseMsgCallBack?.Invoke(t_store_command_response_msg);
                    }
                }
                break;
                //取车请求回馈消息
                case Message.Message_type.EPickupCommandResponseMsg:
                {
                    Message.Pickup_command_response_msg t_pickup_command_response_msg = Message.Pickup_command_response_msg.Parser.ParseFrom(msg);
                    if (t_pickup_command_response_msg?.IdStruct.TerminalId == terminalId)
                    {
                        m_SetPickupResponseMsgCallBack?.Invoke(t_pickup_command_response_msg);
                    }
                }
                break;
                //数据库查询反馈消息
                case Message.Message_type.EParkspaceSearchResponseMsg:
                {
                    Message.Parkspace_search_response_msg t_pickup_search_response_msg = Message.Parkspace_search_response_msg.Parser.ParseFrom(msg);
                    m_SetParkspaceSearchMsgCallBack?.Invoke(t_pickup_search_response_msg);

                }
                break;
                //取车等候区请求通知
                case Message.Message_type.ENotifyRequestMsg:
                {
                        Message.Notify_request_msg t_notify_request_msg = Message.Notify_request_msg.Parser.ParseFrom(msg);
                }
                break;

                //中控状态消息
                case Message.Message_type.ECentralControllerStatuMsg:
                {
                        m_master_control_recv_time = DateTime.Now;
                }
                break;
                //数据库状态消息
                case Message.Message_type.EParkspaceAllocationStatusMsg:
                {
                    m_database_recv_time = DateTime.Now;
                    Message.Parkspace_allocation_status_msg t_parkspace_status_msg = Message.Parkspace_allocation_status_msg.Parser.ParseFrom(msg);
                    Front_terminal_manager.Instance.get_parkspace_status_data_buffer().set_parkspace_status_msg(t_parkspace_status_msg);
                }
                break;
                //雷达状态消息
                case Message.Message_type.EGroundStatusMsg:
                {
                    Message.Ground_status_msg t_ground_status_msg = Message.Ground_status_msg.Parser.ParseFrom(msg);
                    if (t_ground_status_msg?.IdStruct.TerminalId == terminalId)
                    {
                        m_radar_recv_time = DateTime.Now;
                        Front_terminal_manager.Instance.get_ground_radar_data_buffer().set_ground_status_msg(t_ground_status_msg);
                    }
                }
                break;
                //非标模块状态消息
                case Message.Message_type.EUnNormalizedModuleStatuMsg:
                {
                        Message.UnNormalized_module_statu_msg t_UnNormalized_module_status_msg = Message.UnNormalized_module_statu_msg.Parser.ParseFrom(msg);
                        if(t_UnNormalized_module_status_msg?.IdStruct.TerminalId == terminalId)
                        {
                            m_UnNormalized_module_recv_time = DateTime.Now;
                            Front_terminal_manager.Instance.get_unnormalized_module_data_bufferr().set_unnormalized_module_status_msg(t_UnNormalized_module_status_msg);
                        }
                    }
                break;
                default:
                    break;
            }
        }
        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="msg"></param>
        public override void encapsulate_msg(byte[] msg)
        {

            base.encapsulate_msg(msg);
        }
        //重载定时封装
        public override void encapsulate_send_data()
        {

         
        }
        private DateTime m_master_control_recv_time;                 //主控节点消息接收时间
        private DateTime m_radar_recv_time;                          //雷达节点消息接收时间
        private DateTime m_database_recv_time;                       //数据库节消息接收时间
        private DateTime m_UnNormalized_module_recv_time;            //非标节点消息接收时间

        private bool m_master_control_connect_status;                //主控节点连接状态
        private bool m_radar_connect_status;                          //雷达节点连接状态
        private bool m_database_connect_status;                       //数据库节点连接状态
        private bool m_UnNormalized_module_connect_status;            //非标节点连接状态


        protected Thread mp_check_connect_thread;                   //封装的线程
        protected bool m_check_connect_condition;	                //封装的条件变量
        protected EventWaitHandle m_event_exit;                     //防止CPU卡死

    }
}