using GetData_PLC;
using Modbus.Device;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleGetPLCData.CS
{

    public class StateObject
    {
        // Client socket.
        public Socket workSocket = null;
        // Size of receive buffer.
        public const int BufferSize = 1024;
        // Receive buffer.
        public byte[] buffer = new byte[BufferSize];
        // Received data string.
        public StringBuilder sb = new StringBuilder();
    }

    class GetDataThread
    {

        stStation Station = new stStation();
        private ModbusIpMaster master;
        private TcpClient client;
        private bool WriteDateTimeFlag;
        public static ManualResetEvent allDone = new ManualResetEvent(false);

        DataTable dtToday_Flow = new DataTable();   //今日流量总累计 表格
        DataTable dtYesToday_FLOW = new DataTable();//昨日流量总累计 表格
        //private bool readFlag;    //读取盘古积算仪 昨日 今日累积量标志
        bool SaveFlag;    //保存盘古积算仪 总累计量标志
        DataRow[] drDataTemp;//GPRS PLC设备采集上来的数据临时存放，再赋值

        static int intTimes = 0;

        ///构造函数  初始化      
        public GetDataThread(stStation strZhan)
        {
            Station = strZhan;
        }

        /// <summary>
        /// 线程入口函数
        /// </summary>
        public void GetPLCData()
        {

            ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + "开始采集" + Station.ZCName + "数据");

            if (Station.NetTYPE == "0")
            {
                GetDataByNet();
            }

            if (Station.NetTYPE == "1")
            {
                //if (Station.MeterTYPE != "0")
                //{
                GetDataByGPRS_YB();//异步通信

                //}
                //else
                //{
                //GetDataByGPRS_TB();//同步通信
                //}
            }
        }



        #region 局域网采集功能
        /// <summary>
        /// 局域网获取PLC的数据
        /// </summary>
        private void GetDataByNet()
        {

            while (true)
            {
                using (client = new TcpClient())
                {
                    try
                    {
                        client.Connect(Station.ip, Station.port);
                        master = ModbusIpMaster.CreateIp(client);
                        int JldNum = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows.Count;

                    }
                    catch (SystemException err)
                    {
                        if (err.Message != null)
                        {
                            //                       string strZCIDtemp[]=Station.ZCID.Split ('_');
                            //                        if (strZCIDtemp .Length >1)
                            //{

                            //}
                            //                        else 
                            //                        {
                            int JldNum = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows.Count;

                            //}


                            for (int i = 0; i < ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows.Count; i++)  //PLC计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                            {
                                //故障赋值
                                //TranData.netError(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[i]);

                            }

                            foreach (DataRow dr in ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows)
                            {
                                TranData.netError(dr);

                            }
                            ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + Station.ZCID + "网络连接故障！");


                        }
                    }
                    try
                    {
                        int JldNum = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows.Count;

                        ProgramGetData.dsZhanDateTime.Tables[Station.ZCID].Rows[0]["PLCTime"] = getPLCDateTime();  //获取PLC时间
                        SetPLCDateTime(); //同步PLC时间

                        //PLC计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                        foreach (DataRow dr in ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows)
                        {
                            int _jldID = 0;
                            try
                            {
                                _jldID = int.Parse(dr["jld_id"].ToString());
                            }
                            catch (Exception ex)
                            {

                            }
                            DataRow[] drPars = ProgramGetData.dsPparameter.Tables[Station.ZCID].Select("jld_id='" + _jldID.ToString() + "'");
                            //判断是否读取计量点参数
                            if (dr["readparflag"].ToString() == "1")
                            {
                                ushort[] ParWord = master.ReadHoldingRegisters(Convert.ToUInt16((int)(24360 + (240 * _jldID))), 60);
                                drPars[0].ItemArray = TranData.GetPLCPar_Net(drPars[0], ParWord, Station.MeterTYPE).ItemArray;
                                dr["readparflag"] = "0";
                                drPars[0]["ReadTime"] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                            }
                            //采集实时计量数据
                            ushort[] Word = master.ReadHoldingRegisters(Convert.ToUInt16((int)(400 + (20 * _jldID))), 20);
                            //解析数据 根据设备类型解析
                            dr.ItemArray = TranData.GetDataTran_Net(dr, Word, Station.MeterTYPE).ItemArray;
                            //读取计算脉冲仪表的工况流量或雷诺数
                            string strPlusNum = "";

                            try
                            {


                                if (dr["MeterTYPE"].ToString() == "脉冲")
                                {
                                    //采集脉冲数
                                    ushort[] PlusNum = master.ReadHoldingRegisters(Convert.ToUInt16((int)(5000 + (80 * _jldID))), 4);
                                    //采集K系数
                                    ushort[] PlusK = master.ReadHoldingRegisters(Convert.ToUInt16((int)(2600 + (30 * _jldID))), 4);
                                    string ssgkll = TranData.GetFlowGK(PlusNum, PlusK, out strPlusNum);
                                    dr["SSGKLL"] = ssgkll;
                                    string strCxXx = drPars[0]["CLXX"].ToString();
                                    string strCxSx = drPars[0]["CLSX"].ToString();
                                    dr["CXFlag"] = TranData.GetCxFlag(ssgkll, strCxXx, strCxSx);

                                }

                               

                                dr["JLD_NAME"] = drPars[0]["JLD_NAME"];
                                if (dr["MeterTYPE"].ToString() == "脉冲") dr["CY"] = strPlusNum;
                                //差压式流量计则计算雷诺数
                                if (dr["MeterTYPE"].ToString() != "脉冲")
                                {
                                    string strXdmd = drPars[0]["Gr"].ToString();
                                    string strGj = drPars[0]["gj"].ToString();
                                    float sngDlnd = 19768.8f;
                                    string strQn = dr["SSL"].ToString();
                                    if (strQn == "") strQn = "0";
                                    if (strXdmd == "") strXdmd = "0";

                                    if (Station.ZCID == "4708")
                                    {


                                    }

                                    if (strGj != "")
                                    {
                                        dr["SSGKLL"] = (1615.7238 * Convert.ToSingle(strQn) * Convert.ToSingle(strXdmd) / Convert.ToSingle(strGj)).ToString("#.#");
                                    }
                                    dr["CXFlag"] = TranData.GetCxFlag(dr["CY"].ToString());


                                }
                            }
                            catch (Exception ex)
                            {

                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        if (ex.Message != null)
                        {
                            ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + Station.ZCID + "计量点 " + "读取寄存器错误！");
                            continue;
                        }
                    }
                    Thread.Sleep(Station.readDiffTime);

                }
            }

        }
        /// <summary>
        /// 将服务器的时间同步到PLC
        /// </summary>
        private void SetPLCDateTime()
        {
            DateTime SAVETIME = DateTime.Now;

            if ((SAVETIME.Hour.ToString() == "16" && SAVETIME.Minute == 00 && WriteDateTimeFlag == false) || (ProgramGetData.dsZhanDateTime.Tables[Station.ZCID].Rows[0]["TongBuFlag"].ToString() == "同步"))  //到每日23:40 同步时间
            {
                try
                {
                    ushort[] DateData = getTimeData();
                    master.WriteSingleRegister(380, DateData[0]);
                    master.WriteSingleRegister(381, DateData[1]);
                    master.WriteSingleRegister(382, DateData[2]);
                    master.WriteSingleRegister(383, DateData[3]);

                    master.WriteSingleRegister(384, 1);
                    master.WriteSingleRegister(386, 1);

                    ProgramGetData.dsZhanDateTime.Tables[Station.ZCID].Rows[0]["TongBuTime"] = SAVETIME;
                    ProgramGetData.dsZhanDateTime.Tables[Station.ZCID].Rows[0]["TongBuFlag"] = "成功";
                    WriteDateTimeFlag = true;
                }
                catch (SystemException error)
                {
                    if (error.Message != null)
                    {
                        ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + Station.ZCID + "时间同步失败！");
                    }
                }
            }


            if (SAVETIME.Hour.ToString() != "16" && SAVETIME.Minute != 00)  // 同步时间标志位false
            {
                WriteDateTimeFlag = false;
            }



        }
        /// <summary>
        /// 读取局域网站场PLC的时间
        /// </summary>
        /// <returns></returns>
        private string getPLCDateTime()
        {
            //读取站场PLC的系统时间
            ushort[] plc_DateTime = master.ReadHoldingRegisters(16, 4);

            string plc_Year = plc_DateTime[0].ToString("x4");
            string plc_Month = plc_DateTime[1].ToString("x4");
            string plc_Minute = plc_DateTime[2].ToString("x4");
            string plc_Second = plc_DateTime[3].ToString("x4");
            string plcDatetime = plc_Year + "-" + plc_Month.Substring(0, 2) + "-" + plc_Month.Substring(2, 2) + " " + plc_Minute.Substring(0, 2) + ":" + plc_Minute.Substring(2, 2) + ":" + plc_Second;//.Substring(0, 2);// +plc_Second.Substring(2, 2);
            return plcDatetime;
        }
     
        /// <summary>
        /// 将日期时间转换为Ushort类型数组
        /// </summary>
        /// <returns></returns>
        private ushort[] getTimeData()
        {

            ushort[] data = new ushort[4];
            DateTime now = new DateTime();
            now = DateTime.Now;
            string str = "";
            str = now.Year.ToString();
            int num4 = Convert.ToInt16(str.Substring(0, 1));
            int num5 = Convert.ToInt16(str.Substring(1, 1));
            int num6 = Convert.ToInt16(str.Substring(2, 1));
            int num7 = Convert.ToInt16(str.Substring(3, 1));
            data[0] = (ushort)((((((num4 * 0x10) * 0x10) * 0x10) + ((num5 * 0x10) * 0x10)) + (num6 * 0x10)) + num7);
            string str3 = "";
            if (now.Month < 10)
            {
                str3 = str3 + "0" + now.Month.ToString();
            }
            else
            {
                str3 = str3 + now.Month.ToString();
            }
            if (now.Day < 10)
            {
                str3 = str3 + "0" + now.Day.ToString();
            }
            else
            {
                str3 = str3 + now.Day.ToString();
            }
            str = str3;
            num4 = Convert.ToInt16(str.Substring(0, 1));
            num5 = Convert.ToInt16(str.Substring(1, 1));
            num6 = Convert.ToInt16(str.Substring(2, 1));
            num7 = Convert.ToInt16(str.Substring(3, 1));
            data[1] = (ushort)((((((num4 * 0x10) * 0x10) * 0x10) + ((num5 * 0x10) * 0x10)) + (num6 * 0x10)) + num7);
            string str4 = "";
            if (now.Hour < 10)
            {
                str4 = str4 + "0" + now.Hour.ToString();
            }
            else
            {
                str4 = str4 + now.Hour.ToString();
            }
            if (now.Minute < 10)
            {
                str4 = str4 + "0" + now.Minute.ToString();
            }
            else
            {
                str4 = str4 + now.Minute.ToString();
            }
            str = str4;
            num4 = Convert.ToInt16(str.Substring(0, 1));
            num5 = Convert.ToInt16(str.Substring(1, 1));
            num6 = Convert.ToInt16(str.Substring(2, 1));
            num7 = Convert.ToInt16(str.Substring(3, 1));
            data[2] = (ushort)((((((num4 * 0x10) * 0x10) * 0x10) + ((num5 * 0x10) * 0x10)) + (num6 * 0x10)) + num7);
            string str5 = "";
            if (now.Second < 10)
            {
                str5 = str5 + "000" + now.Second.ToString();
            }
            else
            {
                str5 = str5 + "00" + now.Second.ToString();
            }
            str = str5;
            num4 = Convert.ToInt16(str.Substring(0, 1));
            num5 = Convert.ToInt16(str.Substring(1, 1));
            num6 = Convert.ToInt16(str.Substring(2, 1));
            num7 = Convert.ToInt16(str.Substring(3, 1));
            data[3] = (ushort)((((((num4 * 0x10) * 0x10) * 0x10) + ((num5 * 0x10) * 0x10)) + (num6 * 0x10)) + num7);

            return data;

        }
        #endregion





        #region ----------------------同步通讯
        ///////// <summary>
        ///////// 施耐德PLC不带地址的计量点用同步采集，以区分不同计量点
        ///////// </summary>
        ///////// 

        //////private void GetDataByGPRS_TB()
        //////{
        //////    try
        //////    {
        //////        //当点击开始监听的时候 在服务器端创建一个负责监IP地址跟端口号的Socket
        //////        Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        //////        IPAddress ip = IPAddress.Parse(Station.ip);
        //////        //IPAddress ip = IPAddress.Parse("127.0.0.1");
        //////        //创建端口号对象
        //////        IPEndPoint point = new IPEndPoint(ip, Station.port);
        //////        //监听
        //////        socketWatch.Bind(point);
        //////        ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + "监听成功！");
        //////        socketWatch.Listen(10);


        //////        Thread th = new Thread(ListenTB);
        //////        th.IsBackground = true;
        //////        th.Start(socketWatch);



        //////    }
        //////    catch
        //////    { }

        //////}

        //////Socket socketSendTB;


        ///////// <summary>
        ///////// 服务器端不停的接受客户端发送过来的消息
        ///////// </summary>
        ///////// <param name="o"></param>
        //////void Recive(object o)
        //////{
        //////    Socket socketSend = o as Socket;

        //////    try
        //////    {
        //////        byte[] SendByte = new byte[8];
        //////        int ReciveTimes = 0;
        //////        while (true)
        //////        {
        //////            int intJldNum = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows.Count;
        //////            foreach (DataRow dr in ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows)
        //////            {

        //////                //PLC_JLDID = i;
        //////                //Console.WriteLine("读取" + ZcName + "计量点" +PLC_JLDID.ToString()+ "数据");
        //////                string strJLD_Name = dr["JLD_NAME"].ToString();
        //////                int _jldID = Convert.ToInt16(dr["jld_id"].ToString());
        //////                SendByte = TranData.Modbus_ReadData(1, 3, 400 + _jldID * 20, 20);
        //////                socketSend.Send(SendByte);
        //////                Thread.Sleep(1000);
        //////                int dataNum;
        //////                byte[] ReciveByte = new byte[1024];
        //////                dataNum = socketSend.Receive(ReciveByte);
        //////                int bufferLength = ReciveByte.Length;
        //////                dataNum = ReciveByte[2];
        //////                if (dataNum == 40)
        //////                {
        //////                    dr.ItemArray = TranData.GetDataTran_GPRS(dr, ReciveByte, Station.MeterTYPE).ItemArray;
        //////                    dr["JLD_NAME"] = strJLD_Name;
        //////                    if (Station.MeterTYPE == "脉冲")
        //////                    {
        //////                        string ssgkll = dr["SSGKLL"].ToString();
        //////                        //判断工况是否超限
        //////                        try
        //////                        {
        //////                            if (ssgkll != "")
        //////                            {
        //////                                string strCxXx = dr["CLXX"].ToString();
        //////                                string strCxSx = dr["CLSX"].ToString();
        //////                                dr["CXFlag"] = TranData.GetCxFlag(ssgkll, strCxXx, strCxSx);
        //////                            }
        //////                        }
        //////                        catch { }
        //////                    }
        //////                    else
        //////                    {
        //////                        //判断差压是否超限
        //////                        try
        //////                        {
        //////                            dr["CXFlag"] = TranData.GetCxFlag(dr["CY"].ToString());
        //////                        }
        //////                        catch { }
        //////                    }

        //////                }
        //////                else
        //////                {
        //////                    socketSend.Receive(ReciveByte);
        //////                    break;
        //////                    //ProgramGetData.dsJLDataRealTime.Tables[ZCID].Rows[i].ItemArray = TranData.netError(ProgramGetData.dsJLDataRealTime.Tables[ZCID].Rows[i]).ItemArray;
        //////                    //ProgramGetData.dsJLDataRealTime.Tables[ZCID].Rows[i]["JLD_NAME"] = ProgramGetData.dsPparameter.Tables[ZCID].Rows[i]["JLD_NAME"];

        //////                }
        //////            }


        //////            ReciveTimes = ReciveTimes + 1;

        //////            if (DateTime.Now.Hour == 23 && DateTime.Now.Minute == 59)
        //////            {
        //////                Thread.Sleep(2000);
        //////            }
        //////            else
        //////            {
        //////                if (ReciveTimes > 3)  //头四次 采集时间短
        //////                {
        //////                    ReciveTimes = 4;
        //////                    Thread.Sleep(Station.readDiffTime);

        //////                }
        //////                else
        //////                {
        //////                    Thread.Sleep(2000);

        //////                }

        //////            }
        //////        }
        //////    }

        //////    catch
        //////    { }

        //////}
        ///////// <summary>
        ///////// 同步通讯监听
        ///////// </summary>
        ///////// <param name="o"></param>
        //////private void ListenTB(object o)
        //////{
        //////    Socket socketWatch = o as Socket;
        //////    //等待客户端的连接 并且创建一个负责通信的Socket
        //////    while (true)
        //////    {

        //////        try
        //////        {
        //////            try
        //////            {
        //////                //负责跟客户端通信的Socket
        //////                socketSendTB = socketWatch.Accept();
        //////                ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + "连接成功！");

        //////                //开启 一个新线程不停的接受客户端发送过来的消息
        //////                Thread th = new Thread(Recive);
        //////                th.IsBackground = true;
        //////                th.Start(socketSendTB);
        //////            }
        //////            catch
        //////            { }
        //////        }
        //////        catch
        //////        { }
        //////        Thread.Sleep(1000);
        //////    }
        //////}
        #endregion
        #region ---------------------异步通讯
        /// <summary>
        /// 带地址的计量点设备，采用异步通信方式
        /// </summary>
        private void GetDataByGPRS_YB()
        {
            try
            {
                //当点击开始监听的时候 在服务器端创建一个负责监IP地址跟端口号的Socket
                Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPAddress ip = IPAddress.Parse(Station.ip);
                //IPAddress ip = IPAddress.Parse("127.0.0.1");
                //创建端口号对象
                IPEndPoint point = new IPEndPoint(ip, Station.port);
                //监听
                socketWatch.Bind(point);
                socketWatch.Listen(10);
                ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + "监听成功！");

                Thread th = new Thread(Listen);
                th.IsBackground = true;
                th.Start(socketWatch);
                //socketWatch.BeginAccept(new AsyncCallback(AcceptCallback), socketWatch);

            }
            catch (Exception ex)
            {
                ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + ex.Message);

            }


        }

        /// <summary>
        /// 等待客户端的连接 并且创建与之通信用的Socket
        /// </summary>
        /// 
        void Listen(object o)
        {
            Socket socketWatch = o as Socket;
            //等待客户端的连接 并且创建一个负责通信的Socket
            //while (true)
            {
                try
                {
                    //开始一个一步操作接受一个连接尝试
                    socketWatch.BeginAccept(new AsyncCallback(AcceptCallback), socketWatch);
                    //ProgramGetData.strAppend(DateTime.Now.ToString() + "------" + Station.ZCName + "连接成功！");
                    //开启 一个新线程不停的接受客户端发送过来的消息
                }
                catch
                { }
                Thread.Sleep(1000);
            }
        }
        /// <summary>
        /// 异步通信回调函数
        /// </summary>
        /// <param name="ar"></param>
        public void AcceptCallback(IAsyncResult ar)
        {
            //allDone.Set();
            Socket socketSend = (Socket)ar.AsyncState;
            Socket socketRecive = socketSend.EndAccept(ar);
            StateObject state = new StateObject();
            state.workSocket = socketRecive;

            if (Station.MeterTYPE == "1" || Station.MeterTYPE == "5")
            {
                readTodayYesTerdayQL();
            }
            if (Station.MeterTYPE == "0")  //PLC赋值  定义一个数组 暂存 采集上来的所有计量点的数据，再一并赋值给数据集jldID 和ID转换
            {
                int jldMax = ProgramGetData.dsJLDataRealTime.Tables[this.Station.ZCID].Rows.Count;
                int jld_IDMax = Convert.ToInt16(ProgramGetData.dsJLDataRealTime.Tables[this.Station.ZCID].Rows[jldMax - 1]["jld_id"]);

                if (jld_IDMax == 0)
                {
                    drDataTemp = new DataRow[1];

                }
                if (jld_IDMax >= 1)
                {
                    drDataTemp = new DataRow[3];

                }
                if (jld_IDMax >= 3)
                {
                    drDataTemp = new DataRow[6];

                }
                if (jld_IDMax >= 6)
                {
                    drDataTemp = new DataRow[10];

                }
                if (jld_IDMax >= 10)
                {
                    drDataTemp = new DataRow[15];

                }
                if (jld_IDMax >= 15)
                {
                    drDataTemp = new DataRow[21];

                }
                for (int i = 0; i < drDataTemp.Length; i++)
                {
                    DataRow dr = ProgramGetData.dsJLDataRealTime.Tables[this.Station.ZCID].NewRow();
                    drDataTemp[i] = dr;
                    drDataTemp[i]["jld_id"] = i;
                    drDataTemp[i]["STATION_NAME"] = Station.ZCName;
                }
            }
            while (true)
            {

                try
                {

                    byte[] SendByte = new byte[8];
                    Console.WriteLine(DateTime.Now.ToString() + "------" + Station.ZCName + "正在采集......！");
                    switch (Station.MeterTYPE)
                    {
                        case "0": //施耐德PLC   异步通讯 采集计量点数目变化 来判断采集的是哪一个计量点的数据

                            //读取PLC的时钟
                            SendByte = TranData.Modbus_ReadData(1, 3, 16, 4);


                            for (int i = 0; i < drDataTemp.Length; i++)  //计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                            {
                                if (i == 0)  //第一次发一个计量点命令 jldID=0
                                {
                                    SendByte = TranData.Modbus_ReadData(1, 3, 400 + i * 20, 20);
                                }
                                if (i == 1)  //第二次发2个计量点命令 jldID=1,2
                                {
                                    SendByte = TranData.Modbus_ReadData(1, 3, 400 + i * 20, 40);
                                    i = 2;
                                }

                                if (i == 3)  //第三次发3个计量点命令 jldID=3,4,5
                                {
                                    SendByte = TranData.Modbus_ReadData(1, 3, 400 + i * 20, 60);
                                    i = 5;
                                }
                                if (i == 6)  //第4次发4个计量点命令 jldID=6,7,8，9
                                {
                                    SendByte = TranData.Modbus_ReadData(1, 3, 400 + i * 20, 80);
                                    i = 9;
                                }

                                if (i == 10)  //第5次发5个计量点命令 jldID=10,11,12，13,14
                                {
                                    SendByte = TranData.Modbus_ReadData(1, 3, 400 + i * 20, 100);
                                    i = 14;
                                }

                                if (i == 15)  //第5次发5个计量点命令 jldID=15,16,17，18,19,20
                                {
                                    SendByte = TranData.Modbus_ReadData(1, 3, 400 + i * 20, 120);
                                    i = 20;
                                }
                                socketRecive.Send(SendByte);
                                socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_PLC), state);
                                Thread.Sleep(1000);
                            }

                            break;
                        case "1":  //盘古积算仪
                            for (int i = 0; i < ProgramGetData.dsJLDataRealTime.Tables[this.Station.ZCID].Rows.Count; i++)  //计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                            {
                                int _jldID = int.Parse(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[i]["jld_id"].ToString());
                                SendByte = TranData.Modbus_ReadData(_jldID + 1, 3, 0, 16);
                                socketRecive.Send(SendByte);
                                Thread.Sleep(1000);
                                socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_PG), state);

                                if ((DateTime.Now.Hour == 0 & DateTime.Now.Minute == 0 & DateTime.Now.Second == 10))   //过了零点存取累计总量，然后读取昨日累计总量
                                {
                                    SaveFlag = true;
                                }

                                if (SaveFlag)
                                {
                                    SaveTable(0);
                                    readTodayYesTerdayQL();
                                    //Console.WriteLine("存数据库成功" + readFlag.ToString() + timeNow.ToString() + "--" + (SbType == "2" & (timeNow.Hour == 20 & timeNow.Minute == 45 & timeNow.Second > 10) & readFlag == false).ToString ());
                                    SaveFlag = false;
                                }

                            }
                            break;
                        case "2":  //103
                            for (int i = 0; i < ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows.Count; i++)  //计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                            {
                                int _jldID = int.Parse(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[i]["jld_id"].ToString());
                                SendByte = TranData.Modbus_ReadData(_jldID + 1, 3, 7102, 22);
                                socketRecive.Send(SendByte);
                                Thread.Sleep(1000);
                                socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_103), state);
                            }

                            break;
                        case "3":
                            break;
                        case "4":
                            for (int i = 0; i < ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows.Count; i++)  //计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                            {
                                int _jldID = int.Parse(ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[i]["jld_id"].ToString());
                                SendByte = TranData.Modbus_ReadData(_jldID + 1, 3, 511, 15);
                                socketRecive.Send(SendByte);
                                string strMessage = "";
                                for (int j = 0; j < 8; j++)
                                {
                                    strMessage = strMessage + " " + SendByte[j].ToString();
                                }
                                Thread.Sleep(2000);
                                socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_CSB), state);

                            }
                            break;


                        case "5":
                            for (int i = 0; i < ProgramGetData.dsJLDataRealTime.Tables[this.Station.ZCID].Rows.Count; i++)  //计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                            {
                                int _jldID = int.Parse(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[i]["jld_id"].ToString());
                                SendByte = TranData.Modbus_ReadData(_jldID + 1, 3, 4, 30);
                                socketRecive.Send(SendByte);
                                Thread.Sleep(1000);
                                socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_WZFX), state);

                                if ((DateTime.Now.Hour == 0 & DateTime.Now.Minute == 0 & DateTime.Now.Second == 10))   //过了零点存取累计总量，然后读取昨日累计总量
                                {
                                    SaveFlag = true;
                                }

                                if (SaveFlag)
                                {
                                    SaveTable(0);
                                    readTodayYesTerdayQL();
                                    //Console.WriteLine("存数据库成功" + readFlag.ToString() + timeNow.ToString() + "--" + (SbType == "2" & (timeNow.Hour == 20 & timeNow.Minute == 45 & timeNow.Second > 10) & readFlag == false).ToString ());
                                    SaveFlag = false;
                                }

                            }
                            break;


                        case "6":  //腾空PLC
                            for (int i = 0; i < ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows.Count; i++)  //计量点读取循环 循环数由主程序建立该站的实时数据表中的记录数决定
                            {
                                int _jldID = int.Parse(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[i]["jld_id"].ToString());
                                SendByte = TranData.Modbus_ReadData(_jldID + 1, 3, 10100, 22);
                                socketRecive.Send(SendByte);
                                Thread.Sleep(1000);
                                socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_103), state);
                            }

                            break;


                        default:
                            break;
                    }

                }
                catch (Exception ex)
                {
                }

                if (DateTime.Now.Hour == 23 && DateTime.Now.Minute == 59)
                {
                    Thread.Sleep(2000);

                }
                else
                {
                    if (intTimes > 5)
                    {
                        intTimes = 5;
                        Thread.Sleep(Station.readDiffTime);
                    }
                    else
                    {
                        Thread.Sleep(3000);
                    }
                }

                intTimes = intTimes + 1;
            }
        }
        /// <summary>
        /// 解析GPRS读取的PLC数据
        /// </summary>
        /// <param name="ar"></param>

        public void ReadCallback_PLC(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket socketRecive = state.workSocket;
                //从远程设备读取数据
                int bytesRead = socketRecive.EndReceive(ar);
                int dataNum;
                dataNum = state.buffer[2];


                try
                {
                    if (dataNum == 8)  //读取的时钟
                    {
                        ProgramGetData.dsZhanDateTime.Tables[Station.ZCID].Rows[0]["PLCTime"] = getPLCDateTime(state.buffer);  //获取PLC时间  
                    }
                }
                catch
                { }

                try
                {
                    if (dataNum == 40)  // 代表1个计量点 jldID=0
                    {

                        DataRow[] drJldS = { drDataTemp[0] };
                        DataRow[] drData = TranData.GetDataTran_GPRS(drJldS, state.buffer, Station.MeterTYPE);
                        drDataTemp[0].ItemArray = drData[0].ItemArray;

                    }
                }
                catch
                { }

                try
                {
                    if (dataNum == 80)  // 代表2个计量点 jldID=1,2
                    {
                        DataRow[] drJldS = { drDataTemp[1], drDataTemp[2] };
                        DataRow[] drData = TranData.GetDataTran_GPRS(drJldS, state.buffer, Station.MeterTYPE);
                        for (int i = 1; i < 3; i++)
                        {
                            drDataTemp[i].ItemArray = drData[i - 1].ItemArray;
                        }
                    }
                }
                catch
                { }
                try
                {
                    if (dataNum == 120)  // 代表3个计量点 jldID=3,4,5
                    {
                        DataRow[] drJldS = { drDataTemp[3], drDataTemp[4], drDataTemp[5] };
                        DataRow[] drData = TranData.GetDataTran_GPRS(drJldS, state.buffer, Station.MeterTYPE);
                        for (int i = 3; i < 6; i++)
                        {
                            drDataTemp[i].ItemArray = drData[i - 3].ItemArray;
                        }
                    }
                }
                catch
                { }
                try
                {
                    if (dataNum == 160)  // 代表4个计量点 jldID=6,7,8,9
                    {
                        DataRow[] drJldS = { drDataTemp[6], drDataTemp[7], drDataTemp[8], drDataTemp[9] };
                        DataRow[] drData = TranData.GetDataTran_GPRS(drJldS, state.buffer, Station.MeterTYPE);
                        for (int i = 6; i < 10; i++)
                        {
                            drDataTemp[i].ItemArray = drData[i - 6].ItemArray;
                        }
                    }
                }
                catch
                { }
                try
                {
                    if (dataNum == 200)  // 代表5个计量点 jldID=10,11,12,13,14
                    {
                        DataRow[] drJldS = { drDataTemp[10], drDataTemp[11], drDataTemp[12], drDataTemp[13], drDataTemp[14] };
                        DataRow[] drData = TranData.GetDataTran_GPRS(drJldS, state.buffer, Station.MeterTYPE);
                        for (int i = 10; i < 15; i++)
                        {
                            drDataTemp[i].ItemArray = drData[i - 10].ItemArray;
                        }
                    }
                }
                catch
                { }
                try
                {
                    if (dataNum == 240)  // 代表6个计量点 jldID=15,16,17,18,19,20
                    {
                        DataRow[] drJldS = { drDataTemp[15], drDataTemp[16], drDataTemp[17], drDataTemp[18], drDataTemp[19], drDataTemp[20] };
                        DataRow[] drData = TranData.GetDataTran_GPRS(drJldS, state.buffer, Station.MeterTYPE);
                        for (int i = 15; i < 21; i++)
                        {
                            drDataTemp[i].ItemArray = drData[i - 15].ItemArray;
                        }
                    }
                }
                catch
                { }


                //
                foreach (DataRow dr in ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows)
                {
                    int jld_id = Convert.ToInt16(dr["jld_ID"]);

                    ProgramGetData.strAppend("前\t" + DateTime.Now.ToString() + "\t" + strPrint(dr), Station.ZCName);

                    //温度
                    dr["WD"] = drDataTemp[jld_id]["WD"];
                    //压力
                    dr["YL"] = drDataTemp[jld_id]["YL"];
                    //差压
                    dr["CY"] = drDataTemp[jld_id]["CY"];
                    //瞬时量
                    dr["SSL"] = drDataTemp[jld_id]["SSL"];
                    //今日量
                    dr["JRL"] = drDataTemp[jld_id]["JRL"];
                    //昨日量
                    dr["ZRL"] = drDataTemp[jld_id]["ZRL"];
                    //累计量
                    dr["LJL"] = drDataTemp[jld_id]["LJL"];
                    //本月量
                    dr["BYL"] = drDataTemp[jld_id]["BYL"];
                    //上月量
                    dr["SYL"] = drDataTemp[jld_id]["SYL"];
                    //今日时间
                    dr["JRSJ"] = drDataTemp[jld_id]["JRSJ"];
                    //昨日时间
                    dr["ZRSJ"] = drDataTemp[jld_id]["ZRSJ"];
                    //仪表状态                            
                    dr["YBZT"] = drDataTemp[jld_id]["YBZT"];

                    try
                    {
                        if (dr["MeterTYPE"].ToString() == "脉冲")
                        {
                            //计算工况流量
                            Single sngQN;
                            Single sngTf;
                            float sngPf;
                            if (dr["SSL"].ToString() != "")
                            {
                                sngQN = Convert.ToSingle(dr["SSL"].ToString());
                            }
                            else
                            {
                                sngQN = 0;
                            }
                            if (dr["WD"].ToString() != "")
                            {
                                sngTf = float.Parse(dr["WD"].ToString());
                                sngTf = sngTf + 273.15f;
                            }
                            else
                            {
                                sngTf = 0;
                            }

                            if (dr["YL"].ToString() != "" && dr["YL"].ToString() != "0")
                            {
                                sngPf = Convert.ToSingle(dr["YL"].ToString());
                                Single sngFz2;

                                if (sngPf > 0.1 && sngPf < 0.5)
                                {
                                    sngFz2 = 0.999f - 0.008f * (sngPf - 0.1f) / (0.5f - sngPf);

                                }
                                else
                                {
                                    if (sngPf < 0.1) sngFz2 = 0.998f;
                                    if (sngPf > 0.5) sngFz2 = 0.988f;
                                }

                                dr["SSGKLL"] = (sngQN * sngTf * 0.101325 * 0.998 / 293.15 / sngPf / 24).ToString("#.#");

                            }
                            else
                            {
                                dr["SSGKLL"] = 0;
                            }



                            DataRow[] drS = ProgramGetData.dsPparameter.Tables[Station.ZCID].Select("jld_id='" + jld_id + "'");
                            string strXx = drS[0]["CLXX"].ToString();
                            string strSx = drS[0]["CLSX"].ToString();

                            dr["CXFLAG"] = TranData.GetCxFlag(dr["SSGKLL"].ToString(), strXx, strSx);
                            if (jld_id == 3)
                            {

                            }
                        }
                        else
                        {
                            dr["CXFLAG"] = TranData.GetCxFlag(dr["CY"].ToString());
                        }

                    }
                    catch
                    {


                    }


                    ProgramGetData.strAppend("后\t" + DateTime.Now.ToString() + "\t" + strPrint(dr), Station.ZCName);

                    //Console.WriteLine(jld_id.ToString() + "_" + dr["SSL"] + "_" + dr["CY"]);
                }

                socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_PLC), state);

            }
            catch (Exception ex)
            {
            }
        }

        /// <summary>
        /// 对于没在PLC的设备，每次采集程序启动读取存储的昨日量 今日量的总累积量
        /// </summary>
        private void readTodayYesTerdayQL()
        {
            DateTime _Date = DateTime.Now.AddDays(-1);
            _Date = DateTime.Parse(_Date.ToString("yyyy-MM-dd"));
            string strSQL = SQL_Strings.strSQL_Read_Today_YesterDay_Flow + " where STATION_ID='" + Station.ZCID + "' and  RTIME=to_date('" + _Date.ToShortDateString() + "', 'yyyy-mm-dd') order by JLD_ID";
            dtToday_Flow = OracleLink.ExecuteDataTable(strSQL, "DTJK", "");
            strSQL = SQL_Strings.strSQL_Read_Today_YesterDay_Flow + " where STATION_ID='" + Station.ZCID + "' and  RTIME=to_date('" + _Date.AddDays(-1).ToShortDateString() + "', 'yyyy-mm-dd') order by JLD_ID";
            dtYesToday_FLOW = OracleLink.ExecuteDataTable(strSQL, "DTJK", "");
        }
        /// <summary>
        /// 保存昨日量、今日量到数据库
        /// </summary>
        /// <param name="intSaveFlag"></param>
        private void SaveTable(int intSaveFlag)
        {
            SaveFlag = true;
            Thread.Sleep(2000);
            string strSQL = SQL_Strings.strSQL_Read_Today_YesterDay_Flow + " where STATION_ID='" + Station.ZCID + "'";
            OracleLink.SaveDataTable(strSQL, dtToday_Flow, "DTJK", "");
        }

        /// <summary>
        /// 获取并解析福鑫的数据
        /// </summary>
        /// <param name="ar"></param>
        public void ReadCallback_WZFX(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket socketRecive = state.workSocket;
                //从远程设备读取数据
                int bytesRead = socketRecive.EndReceive(ar);
                int dataNum;
                dataNum = state.buffer[2];
                int jldID = state.buffer[0] - 1;
                if (dataNum == 60)
                {
                    ProgramGetData.strAppend("前\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);

                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID].ItemArray = TranData.GetDataTran_GPRS(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID], state.buffer, Station.MeterTYPE).ItemArray;
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"] = ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"];
                    try
                    {
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["CXFlag"] = TranData.GetCxFlag(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SSGKLL"].ToString(), ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["CLXX"].ToString(), ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["CLSX"].ToString());
                    }
                    catch { }

                    ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["Gr"] = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SYL"];
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SYL"] = "";
                    ProgramGetData.strAppend("后\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);

                    socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_WZFX), state);
                }
                #region //提取昨日凌晨总累积量 计算今日量
                try
                {
                    string strTotalFlowNow = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["LJL"].ToString();
                    DataRow[] drTotay; ;
                    drTotay = dtToday_Flow.Select("JLD_ID in( '" + jldID + "')");
                    //Console.WriteLine("时间：" + DateTime.Now + "JLD_ID in( '" + jldID + "')--" + drTotay.Length.ToString() + "\n");
                    if (drTotay.Length == 0)  //如果今日流量记录为空 把当前的流量总量写入表格 并保存到数据库中
                    {
                        DataRow drToday = dtToday_Flow.NewRow();
                        drToday["rtime"] = DateTime.Parse(DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd"));
                        drToday["station_id"] = Station.ZCID;
                        drToday["jld_id"] = jldID;
                        drToday["flowtotal"] = strTotalFlowNow;
                        dtToday_Flow.Rows.Add(drToday);
                        SaveFlag = true;
                    }
                    else
                    {
                        //今日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["JRL"] = float.Parse(strTotalFlowNow) - float.Parse(drTotay[0]["flowtotal"].ToString());
                    }

                    DataRow[] drYesterday;
                    drYesterday = dtYesToday_FLOW.Select("JLD_ID in ('" + jldID + "')");
                    //Console.WriteLine("时间：" + DateTime.Now + "JLD_ID in( '" + jldID + "')--" + drYesterday.Length.ToString() + "\n");
                    if (drYesterday.Length < 1)
                    {
                        //昨日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["ZRL"] = "";
                    }
                    else
                    {
                        //昨日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["ZRL"] = float.Parse(drTotay[0]["flowtotal"].ToString()) - float.Parse(drYesterday[0]["flowtotal"].ToString()); ;
                    }

                }
                catch { }

                #endregion
            }
            catch
            {

            }
        }

        /// <summary>
        /// 获取并解析盘古积算仪的数据
        /// </summary>
        /// <param name="ar"></param>
        public void ReadCallback_PG(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket socketRecive = state.workSocket;
                //从远程设备读取数据
                int bytesRead = socketRecive.EndReceive(ar);
                int dataNum;
                dataNum = state.buffer[2];
                int jldID = state.buffer[0] - 1;
                if (dataNum == 32)
                {
                    ProgramGetData.strAppend("前\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID].ItemArray = TranData.GetDataTran_GPRS(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID], state.buffer, Station.MeterTYPE).ItemArray;
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"] = ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"];
                    try
                    {
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["CXFlag"] = TranData.GetCxFlag(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SSGKLL"].ToString(), ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["CLXX"].ToString(), ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["CLSX"].ToString());
                    }
                    catch (Exception ex)
                    { }

                    ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["Gr"] = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SYL"];
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SYL"] = "";
                    ProgramGetData.strAppend("后\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);
                    socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_PG), state);
                }
                #region //提取昨日凌晨总累积量 计算今日量
                try
                {
                    string strTotalFlowNow = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["LJL"].ToString();
                    DataRow[] drTotay; ;
                    drTotay = dtToday_Flow.Select("JLD_ID in( '" + jldID + "')");
                    //Console.WriteLine("时间：" + DateTime.Now + "JLD_ID in( '" + jldID + "')--" + drTotay.Length.ToString() + "\n");
                    if (drTotay.Length == 0)  //如果今日流量记录为空 把当前的流量总量写入表格 并保存到数据库中
                    {
                        DataRow drToday = dtToday_Flow.NewRow();
                        drToday["rtime"] = DateTime.Parse(DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd"));
                        drToday["station_id"] = Station.ZCID;
                        drToday["jld_id"] = jldID;
                        drToday["flowtotal"] = strTotalFlowNow;
                        dtToday_Flow.Rows.Add(drToday);
                        SaveFlag = true;
                    }
                    else
                    {
                        //今日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["JRL"] = float.Parse(strTotalFlowNow) - float.Parse(drTotay[0]["flowtotal"].ToString());
                    }
                    DataRow[] drYesterday;
                    drYesterday = dtYesToday_FLOW.Select("JLD_ID in ('" + jldID + "')");
                    //Console.WriteLine("时间：" + DateTime.Now + "JLD_ID in( '" + jldID + "')--" + drYesterday.Length.ToString() + "\n");
                    if (drYesterday.Length < 1)
                    {
                        //昨日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["ZRL"] = "";
                    }
                    else
                    {
                        //昨日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["ZRL"] = float.Parse(drTotay[0]["flowtotal"].ToString()) - float.Parse(drYesterday[0]["flowtotal"].ToString()); ;
                    }

                }
                catch { }

                #endregion
            }
            catch
            {

            }
        }
        /// <summary>
        /// 获取并解析爱知超声波的数据
        /// </summary>
        /// <param name="ar"></param>
        public void ReadCallback_CSB(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket socketRecive = state.workSocket;
                //从远程设备读取数据
                int bytesRead = socketRecive.EndReceive(ar);
                int dataNum;
                dataNum = state.buffer[2];
                int jldID = state.buffer[0] - 1;
                if (dataNum == 30)
                {
                    ProgramGetData.strAppend("前\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);

                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID].ItemArray = TranData.GetDataTran_GPRS(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID], state.buffer, Station.MeterTYPE).ItemArray;
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"] = ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"];
                    try
                    {
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["CXFlag"] = TranData.GetCxFlag(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SSGKLL"].ToString(), ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["CLXX"].ToString(), ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["CLSX"].ToString());
                    }
                    catch { }

                    ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["Gr"] = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SYL"];
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["SYL"] = "";
                    ProgramGetData.strAppend("后\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);

                    socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_PG), state);
                }
                #region //提取昨日凌晨总累积量 计算今日量
                try
                {
                    string strTotalFlowNow = ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["LJL"].ToString();
                    DataRow[] drTotay; ;
                    drTotay = dtToday_Flow.Select("JLD_ID in( '" + jldID + "')");
                    //Console.WriteLine("时间：" + DateTime.Now + "JLD_ID in( '" + jldID + "')--" + drTotay.Length.ToString() + "\n");
                    if (drTotay.Length == 0)  //如果今日流量记录为空 把当前的流量总量写入表格 并保存到数据库中
                    {
                        DataRow drToday = dtToday_Flow.NewRow();
                        drToday["rtime"] = DateTime.Parse(DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd"));
                        drToday["station_id"] = Station.ZCID;
                        drToday["jld_id"] = jldID;
                        drToday["flowtotal"] = strTotalFlowNow;
                        dtToday_Flow.Rows.Add(drToday);
                        SaveFlag = true;
                    }
                    else
                    {
                        //今日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["JRL"] = float.Parse(strTotalFlowNow) - float.Parse(drTotay[0]["flowtotal"].ToString());
                    }

                    DataRow[] drYesterday;
                    drYesterday = dtYesToday_FLOW.Select("JLD_ID in ('" + jldID + "')");
                    //Console.WriteLine("时间：" + DateTime.Now + "JLD_ID in( '" + jldID + "')--" + drYesterday.Length.ToString() + "\n");
                    if (drYesterday.Length < 1)
                    {
                        //昨日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["ZRL"] = "";
                    }
                    else
                    {
                        //昨日量
                        ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["ZRL"] = float.Parse(drTotay[0]["flowtotal"].ToString()) - float.Parse(drYesterday[0]["flowtotal"].ToString()); ;
                    }

                }
                catch { }

                #endregion
            }
            catch
            {

            }
        }
        /// <summary>
        /// 获得打印数据监视字符串
        /// </summary>
        /// <param name="dr"></param>
        /// <returns></returns>
        private string strPrint(DataRow dr)
        {
            return dr["JLD_NAME"] + "\t瞬时量：" + dr["SSL"] + "\t温度：" + dr["WD"] + "\t压力：" + dr["YL"] + "\t累积量：" + dr["LJL"];
        }

        /// <summary>
        /// 获取并解析103的数据
        /// </summary>
        /// <param name="ar"></param>
        public void ReadCallback_103(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket socketRecive = state.workSocket;
                //从远程设备读取数据
                int bytesRead = socketRecive.EndReceive(ar);
                int dataNum;
                dataNum = state.buffer[2];
                int jldID = state.buffer[0] - 1;
                if (dataNum == 44)
                {
                    ProgramGetData.strAppend("前\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID].ItemArray = TranData.GetDataTran_GPRS(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID], state.buffer, Station.MeterTYPE).ItemArray;
                    ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"] = ProgramGetData.dsPparameter.Tables[Station.ZCID].Rows[jldID]["JLD_NAME"];
                    socketRecive.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback_103), state);
                    ProgramGetData.strAppend("后\t" + DateTime.Now.ToString() + "\t" + strPrint(ProgramGetData.dsJLDataRealTime.Tables[Station.ZCID].Rows[jldID]), Station.ZCName);
                }
            }
            catch
            {
            }

        }


        /// <summary>
        /// 读取GPRS站场PLC的时间
        /// </summary>
        /// <returns></returns>
        private string getPLCDateTime(byte[] plc_DateTime)
        {

            string[] Uplc_DateTime = new string[4];

            Uplc_DateTime[0] = plc_DateTime[4].ToString("X2") + plc_DateTime[3].ToString("X2");
            Uplc_DateTime[1] = plc_DateTime[6].ToString("X2") + plc_DateTime[5].ToString("X2");
            Uplc_DateTime[2] = plc_DateTime[8].ToString("X2") + plc_DateTime[7].ToString("X2");
            Uplc_DateTime[3] = plc_DateTime[10].ToString("X2") + plc_DateTime[9].ToString("X2");

            string plc_Year = Uplc_DateTime[0];
            string plc_Month = Uplc_DateTime[1];
            string plc_Minute = Uplc_DateTime[2];
            string plc_Second = Uplc_DateTime[3];
            string plcDatetime = plc_Year + "-" + plc_Month.Substring(0, 2) + "-" + plc_Month.Substring(2, 2) + " " + plc_Minute.Substring(0, 2) + ":" + plc_Minute.Substring(2, 2) + ":" + plc_Second;//.Substring(0, 2);// +plc_Second.Substring(2, 2);
            return plcDatetime;
        }

        #endregion




    }
}