chutian_terminal/communication/singlechip_communication.cs

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

namespace chutian_parking_terminal.communication
{
    public class Singlechip_communication : Communication_socket_tcp_base
    {
        //由于C#不能多继承 就只能直接写成单例模式了
        /// <summary>
        /// 单例
        /// </summary>
        class Nested
        {
            // 创建模板类实例，参数2设为true表示支持私有构造函数
            internal static readonly Singlechip_communication instance = Activator.CreateInstance(typeof(Singlechip_communication), true) as Singlechip_communication;
        }
        private static Singlechip_communication instance = null;
        public static Singlechip_communication Instance
        {
            get
            {
                return Nested.instance;
            }
        }
        
        public int m_stop_singlechip_index;
        public int terminalId;

        private Singlechip_communication()
        {
        }
        /// <summary>
        /// 初始化单片机通信，停车单片机默认最后一个连接
        /// </summary>
        public void singlechip_communication_init()
        {
            terminalId = int.Parse(json_file_operation.Instance.read_json_string("ternimalNumber"));
            JArray t_ip_array = json_file_operation.Instance.read_json_jarray("pickup_singleChipAddress");
            JArray t_port_array = json_file_operation.Instance.read_json_jarray("pickup_singleChipPort");
            t_ip_array.Add(json_file_operation.Instance.read_json_string("singleChipAddress"));
            t_port_array.Add(json_file_operation.Instance.read_json_string("singleChipPort"));

            m_stop_singlechip_index = t_ip_array.Count-1;
            base.communication_socket_tcp_init(t_ip_array, t_port_array);
        }
        public void singlechip_communication_connect()
        {
            base.communication_socket_tcp_connect();
        }
        public void singlechip_communication_uninit()
        {
            base.communication_socket_tcp_uninit();
        }
        /// <summary>
        /// 检查入口状态
        /// </summary>
        /// <returns></returns>
        public bool check_entrance_statu()
        {
            if (m_communication_status[m_stop_singlechip_index] == Communication_socket_tcp_statu.COMMUNICATION_TCP_READY)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查出口状态
        /// </summary>
        /// <returns></returns>
        public bool check_exit_statu()
        {
            return true;
            for (int index = 0; index < base.m_connect_count-1; ++index)
            {
                if (m_communication_status[index] != Communication_socket_tcp_statu.COMMUNICATION_TCP_READY)
                {
                    return false;
                }
            }
            return true;
        }
        //重载处理消息
        public override void execute_msg(int index,string msg)
        {
            //Console.WriteLine(msg);

            if (msg.Contains("InPutDi"))
            {
                Message.Singlechip_data t_singlechip_msg = Message.Singlechip_data.Parser.ParseJson(msg);

                if (t_singlechip_msg.DispatchDirection == 1)
                {
                    Front_terminal_manager.Instance.get_singlechip_data_bufferr().set_entrance_singlechip_msg(t_singlechip_msg);
                    Message.Terminal_status_msg terminal_Status_Msg = new Message.Terminal_status_msg();
                    Message.Base_info base_Info = new Message.Base_info();
                    base_Info.MsgType = Message.Message_type.ETerminalStatusMsg;
                    base_Info.Sender = Message.Communicator.ETerminor;
                    base_Info.Receiver = Message.Communicator.EEmpty;
                    base_Info.TimeoutMs = 1000;


                    Message.Singlechip_data singlechip_data = new Message.Singlechip_data();
                    if (Singlechip_communication.Instance.check_entrance_statu())
                    {
                        singlechip_data = Front_terminal_manager.Instance.get_singlechip_data_bufferr().get_entrance_singlechip_msg();
                        terminal_Status_Msg.SinglechipValidity = true;

                    }
                    else
                    {
                        terminal_Status_Msg.SinglechipValidity = false;
                    }
                    singlechip_data.TerminalID = terminalId;
                    singlechip_data.DispatchDirection = 1;
                    terminal_Status_Msg.BaseInfo = base_Info;
                    Message.Id_struct id_Struct = new Message.Id_struct();
                    id_Struct.TerminalId = terminalId;
                    terminal_Status_Msg.IdStruct = id_Struct;
                    terminal_Status_Msg.SinglechipData = singlechip_data;
                    Channel_communication.Instance.encapsulate_msg(terminal_Status_Msg.ToByteArray());
                    //Console.WriteLine("发送的---:" + terminal_Status_Msg.ToString() + "    " +  DateTime.Now.Millisecond);

                }
                else if (t_singlechip_msg.DispatchDirection == 2)
                {
                    Front_terminal_manager.Instance.get_singlechip_data_bufferr().set_exit_singlechip_msg(index, t_singlechip_msg);
                }
            }

        }
        //重载封装消息
        public override void encapsulate_msg(int index,string message)
        {

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


            //encapsulate_msg(m_stop_singlechip_index, Front_terminal_manager.Instance.get_singlechip_data_bufferr().get_entrance_terminal_msg().ToString());
            //for (int i = 0; i < this.m_connect_count; ++i)
            //{
            //    if ( i!= m_stop_singlechip_index )
            //    {
            //        string exit_terminal_msg = new JsonFormatter(JsonFormatter.Settings.Default).Format(Front_terminal_manager.Instance.get_singlechip_data_bufferr().get_exit_terminal_msg(i));
            //        encapsulate_msg(i, exit_terminal_msg);
            //    }
            //}
        }
    }
}